@opencode/codemode 0.0.0-beta-19365 → 0.0.0-beta-19381

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, PromiseMethodReference } from "./model.js";
-import { type CallbackRunner } from "./methods.js";
+import { type AstNode, InterpreterRuntimeError, PromiseInstanceMethodReference } from "./model.js";
+import { HostFunction } from "./host.js";
 import { Values } from "../values.js";
-import type { SyncIteratorRunner } from "./iterator.js";
+import { type Runner } from "./runner.js";
 export declare class PromiseRuntime<R> {
     private readonly scope;
     private readonly active;
@@ -20,10 +20,9 @@ export declare class PromiseRuntime<R> {
     interrupt(): Effect.Effect<Array<Diagnostic>>;
 }
 export declare const selfResolutionError: (node?: AstNode) => InterpreterRuntimeError;
-export declare const resolvePromiseValue: <R>(runner: CallbackRunner<R>, value: unknown, node: AstNode, own?: {
+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: CallbackRunner<R>, promises: PromiseRuntime<R>, value: unknown, node: AstNode) => Effect.Effect<Values.Promise, 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<Values.Promise, never, R>;
-export declare const constructPromise: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, executor: unknown, node: AstNode) => Effect.Effect<Values.Promise, 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

@@ -1,10 +1,16 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
-import { CodeModeFunction, InterpreterRuntimeError, ProgramThrow, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, } from "./model.js";
+import { CodeModeFunction, InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference, } from "./model.js";
+import { HostFunction, requiresNew, sync } from "./host.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;
+});
 // Observation only controls rejection reporting; program completion interrupts all promise work.
 export class PromiseRuntime {
     scope;
@@ -83,12 +89,8 @@ 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 = new PromiseCapabilityFunction((result) => {
-            Deferred.doneUnsafe(deferred, Exit.succeed(result));
-        });
-        const reject = new PromiseCapabilityFunction((reason) => {
-            Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason)));
-        });
+        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))
@@ -107,17 +109,18 @@ export const resolvePromise = (runner, promises, value, node) => {
         return promise;
     });
 };
-export const invokePromiseMethod = (runner, promises, ref, args, node) => {
-    if (ref.name === "resolve") {
+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 (ref.name === "reject") {
+    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.${ref.name} expects an array or other synchronous iterable.`, node).as("TypeError");
+            throw new InterpreterRuntimeError(`Promise.${name} expects an array or other synchronous iterable.`, node).as("TypeError");
         }
         const items = [];
         while (true) {
@@ -128,10 +131,10 @@ export const invokePromiseMethod = (runner, promises, ref, args, node) => {
             promises.markObserved(item);
             items.push(item);
         }
-        if (ref.name === "all") {
+        if (name === "all") {
             return yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" }));
         }
-        if (ref.name === "allSettled") {
+        if (name === "allSettled") {
             const outcomes = [];
             for (const item of items) {
                 const exit = yield* promises.await(item);
@@ -149,7 +152,7 @@ export const invokePromiseMethod = (runner, promises, ref, args, node) => {
             yield* Effect.yieldNow;
             return outcomes;
         }
-        if (ref.name === "race") {
+        if (name === "race") {
             if (items.length === 0) {
                 throw new InterpreterRuntimeError("Promise.race([]) would never settle; provide at least one promise or value.", node);
             }
@@ -175,7 +178,7 @@ 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);
 };
-export const constructPromise = (runner, promises, executor, node) => {
+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");
     }
@@ -184,12 +187,8 @@ export const constructPromise = (runner, promises, executor, node) => {
         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 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))
@@ -251,3 +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({
+        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.js

@@ -1,24 +1,16 @@
-import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, IteratorSymbol, JsonMethodReference, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, PromiseNamespace, SearchFunction, SymbolNamespace, UriFunction, } from "./model.js";
 import { ToolReference } from "../tool-runtime.js";
 import { Values } from "../values.js";
-export const isRuntimeReference = (value) => value instanceof CodeModeFunction ||
+import { HostFunction, HostNamespace } from "./host.js";
+import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, IteratorSymbol, PromiseInstanceMethodReference, } from "./model.js";
+export const isRuntimeReference = (value) => value instanceof HostFunction ||
+    value instanceof HostNamespace ||
+    value instanceof CodeModeFunction ||
     value instanceof CodeModeGenerator ||
     value instanceof GeneratorMethodReference ||
     value instanceof ToolReference ||
     value instanceof IntrinsicReference ||
-    value instanceof GlobalNamespace ||
-    value instanceof GlobalMethodReference ||
-    value instanceof JsonMethodReference ||
-    value instanceof PromiseNamespace ||
-    value instanceof PromiseMethodReference ||
     value instanceof PromiseInstanceMethodReference ||
     value instanceof Values.Promise ||
-    value instanceof CoercionFunction ||
-    value instanceof UriFunction ||
-    value instanceof SearchFunction ||
-    value instanceof PromiseCapabilityFunction ||
-    value instanceof ErrorConstructorReference ||
-    value instanceof SymbolNamespace ||
     Values.isValue(value);
 function* childValues(value) {
     for (const key of Reflect.ownKeys(value)) {
@@ -59,25 +51,16 @@ export const rejectCircularInsertion = (container, value, label, node, seen = ne
     }
 };
 export const typeofValue = (value) => {
-    if (value instanceof CodeModeFunction ||
+    if (value instanceof HostFunction ||
+        value instanceof CodeModeFunction ||
         value instanceof GeneratorMethodReference ||
-        value instanceof CoercionFunction ||
         value instanceof IntrinsicReference ||
-        value instanceof GlobalMethodReference ||
-        value instanceof JsonMethodReference ||
-        value instanceof PromiseMethodReference ||
-        value instanceof PromiseInstanceMethodReference ||
-        value instanceof PromiseNamespace ||
-        value instanceof PromiseCapabilityFunction ||
-        value instanceof ErrorConstructorReference ||
-        value instanceof SymbolNamespace)
-        return "function";
-    if (value instanceof UriFunction || value instanceof SearchFunction)
+        value instanceof PromiseInstanceMethodReference) {
         return "function";
+    }
+    if (value instanceof HostNamespace)
+        return "object";
     if (value instanceof ToolReference)
         return value.path.length > 0 ? "function" : "object";
-    if (value instanceof GlobalNamespace) {
-        return value.name === "Math" || value.name === "JSON" || value.name === "console" ? "object" : "function";
-    }
     return typeof value;
 };

package/dist/interpreter/runner.d.ts

@@ -0,0 +1,23 @@
+import { Effect } from "effect";
+import { Values } from "../values.js";
+import { HostFunction } from "./host.js";
+import { type AstNode, CodeModeFunction, IntrinsicReference } from "./model.js";
+export type IteratorCursor<R> = {
+    readonly next: Effect.Effect<{
+        readonly done: boolean;
+        readonly value: unknown;
+    }, unknown, R>;
+    readonly close: Effect.Effect<void, unknown, R>;
+};
+/** Everything a host function needs to call back into the program. */
+export type Runner<R> = {
+    readonly invokeFunction: (fn: CodeModeFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly invokeCallable: (callable: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+    readonly settlePromise: (promise: Values.Promise) => Effect.Effect<unknown, unknown, never>;
+    readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
+};
+export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
+export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string", node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export type SupportedCallback = CodeModeFunction | HostFunction<unknown> | IntrinsicReference;
+export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;
+export declare const applyCollectionCallback: <R>(runner: Runner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);

package/dist/interpreter/runner.js

@@ -0,0 +1,42 @@
+import { Effect, Exit } from "effect";
+import { Values } from "../values.js";
+import { coerceToString } from "../stdlib/value.js";
+import { HostFunction } from "./host.js";
+import { CodeModeFunction, InterpreterRuntimeError, IntrinsicReference } from "./model.js";
+import { typeofValue } from "./references.js";
+export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
+    ? Effect.succeed(exit.value)
+    : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)));
+export const toPrimitive = (runner, value, hint, node) => {
+    if (value === null || typeof value !== "object")
+        return Effect.succeed(value);
+    if (Values.isValue(value)) {
+        return Effect.succeed(value instanceof Values.Date && hint === "number" ? value.time : coerceToString(value));
+    }
+    const object = value;
+    const order = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
+    return Effect.gen(function* () {
+        for (const method of order) {
+            if (method === "toString" && !Object.hasOwn(object, "toString"))
+                return coerceToString(value);
+            if (!Object.hasOwn(object, method) || typeofValue(object[method]) !== "function")
+                continue;
+            const result = yield* runner.invokeCallable(object[method], [], node);
+            if (result === null || (typeof result !== "object" && typeof result !== "function"))
+                return result;
+        }
+        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
+    });
+};
+export const isSupportedCallback = (value) => value instanceof CodeModeFunction ||
+    (value instanceof HostFunction && value.callback) ||
+    value instanceof IntrinsicReference;
+export const applyCollectionCallback = (runner, callback, name, node) => {
+    if (!isSupportedCallback(callback)) {
+        if (typeofValue(callback) === "function") {
+            throw new InterpreterRuntimeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
+        }
+        throw new InterpreterRuntimeError(`${name} expects a function callback.`, node).as("TypeError");
+    }
+    return (callbackArgs) => runner.invokeCallable(callback, callbackArgs, node);
+};

package/dist/interpreter/runtime.d.ts

@@ -1,97 +1,16 @@
 import type { Program } from "acorn";
 import { Effect } from "effect";
+import { type Runner } from "./runner.js";
 import { PromiseRuntime } from "./promises.js";
-export declare class Interpreter<R> {
-    private scopes;
-    private readonly executeTool;
-    private readonly invokeSearch;
-    private readonly toolKeys;
-    private readonly logs;
-    private readonly promises;
-    private generatorState?;
-    private generatorAsync;
-    private readonly runner;
-    constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, invokeSearch: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, logs?: Array<string>);
+/** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
+export declare class Runtime<R> {
+    readonly executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
+    readonly promises: PromiseRuntime<R>;
+    readonly logs: Array<string>;
+    readonly runner: Runner<R>;
+    private readonly root;
+    constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, logs?: Array<string>);
     run(program: Program): Effect.Effect<unknown, unknown, R>;
-    private createToolCallPromise;
-    private createPromise;
-    private settlePromise;
-    private evaluateStatement;
-    private evaluateBlock;
-    private createFunction;
-    private hoistFunctions;
-    private predeclareLexical;
-    private predeclarePattern;
-    private evaluateIfStatement;
-    private evaluateSwitchStatement;
-    private evaluateWhileStatement;
-    private evaluateDoWhileStatement;
-    private evaluateForStatement;
-    private evaluateForOfStatement;
-    private awaitValue;
-    private awaitAsyncFromSyncValue;
-    private syncIterator;
-    private customIterator;
-    private nextIteratorResult;
-    private closeIterator;
-    private requireIteratorObject;
-    private requireIterator;
-    private requireIteratorMethod;
-    private enumerableKeys;
-    private evaluateForInStatement;
-    private evaluateBreakStatement;
-    private evaluateContinueStatement;
-    private evaluateLabeledStatement;
-    private evaluateThrowStatement;
-    private evaluateTryStatement;
-    private evaluateVariableDeclaration;
-    private declarePattern;
-    private assignPattern;
-    private destructureArrayPattern;
-    private destructuringPropertyKey;
-    private destructuringPropertyValue;
-    private evaluateExpression;
-    private evaluateNewExpression;
-    private constructArray;
-    private constructObject;
-    private constructDate;
-    private constructRegExp;
-    private constructMap;
-    private constructSet;
-    private constructURL;
-    private constructURLSearchParams;
-    private readURLSearchParamsPair;
-    private evaluateBinaryExpression;
-    private applyBinaryOperator;
-    private evaluateLogicalExpression;
-    private evaluateUnaryExpression;
-    private evaluateAssignmentExpression;
-    private evaluateLogicalAssignment;
-    private evaluateUpdateExpression;
-    private evaluateCallExpression;
-    private invokeCallable;
-    private invokeObjectMethodOnTools;
-    private invokeConsole;
-    private evaluateCallArguments;
-    private invokeFunction;
-    private createGenerator;
-    private completeGeneratorRequests;
-    private takeGeneratorRequest;
-    private dequeueGeneratorRequest;
-    private evaluateYieldExpression;
-    private suspendGenerator;
-    private delegateYield;
-    private evaluateObjectExpression;
-    private evaluateArrayExpression;
-    private evaluateTemplateLiteral;
-    private evaluateConditionalExpression;
-    private applyCompoundAssignment;
-    private getMemberReference;
-    private readMember;
-    private writeMember;
-    private evaluateDeleteExpression;
-    private modifyMember;
-    private readReferenceValue;
-    private assignToReference;
-    private toPropertyKey;
 }