@opencode/codemode 0.0.0-beta-19425 → 0.0.0-beta-19507

package/dist/interpreter/objects.d.ts

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

package/dist/interpreter/objects.js

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

package/dist/interpreter/promises.d.ts

@@ -12,6 +12,9 @@ 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>>;

package/dist/interpreter/promises.js

@@ -1,5 +1,6 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
-import { CodeModeFunction, InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference, } from "./model.js";
+import { InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference } from "./model.js";
+import { get, ProgramArray, ProgramFunction, ProgramObject, record } from "./objects.js";
 import { HostFunction, requiresNew, sync } from "./host.js";
 import { caughtErrorValue, normalizeError } from "./errors.js";
 import { typeofValue } from "./references.js";
@@ -22,6 +23,14 @@ 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.
@@ -80,9 +89,9 @@ export const resolvePromiseValue = (runner, value, node, own) => {
         return Effect.fail(selfResolutionError(node));
     if (value instanceof Values.Promise)
         return runner.settlePromise(value);
-    if (value === null || typeof value !== "object" || !Object.hasOwn(value, "then"))
+    if (!(value instanceof ProgramObject))
         return Effect.succeed(value);
-    const then = value.then;
+    const then = get(value, "then");
     if (typeofValue(then) !== "function")
         return Effect.succeed(value);
     return Effect.gen(function* () {
@@ -103,11 +112,7 @@ export const resolvePromiseValue = (runner, value, node, own) => {
 export const resolvePromise = (runner, promises, value, node) => {
     if (value instanceof Values.Promise)
         return Effect.succeed(value);
-    const box = {};
-    return Effect.map(promises.create(resolvePromiseValue(runner, value, node, box)), (promise) => {
-        box.promise = promise;
-        return promise;
-    });
+    return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self));
 };
 const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"];
 const invokePromiseMethod = (runner, promises, name, args, node) => {
@@ -132,25 +137,22 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
             items.push(item);
         }
         if (name === "all") {
-            return yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" }));
+            return new ProgramArray(yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" })));
         }
         if (name === "allSettled") {
             const outcomes = [];
             for (const item of items) {
                 const exit = yield* promises.await(item);
                 if (Exit.isSuccess(exit)) {
-                    outcomes.push(Object.assign(Object.create(null), { status: "fulfilled", value: exit.value }));
+                    outcomes.push(record({ status: "fulfilled", value: exit.value }));
                     continue;
                 }
                 if (Cause.hasInterruptsOnly(exit.cause))
                     return yield* Effect.failCause(exit.cause);
-                outcomes.push(Object.assign(Object.create(null), {
-                    status: "rejected",
-                    reason: caughtErrorValue(Cause.squash(exit.cause)),
-                }));
+                outcomes.push(record({ status: "rejected", reason: caughtErrorValue(Cause.squash(exit.cause)) }));
             }
             yield* Effect.yieldNow;
-            return outcomes;
+            return new ProgramArray(outcomes);
         }
         if (name === "race") {
             if (items.length === 0) {
@@ -179,14 +181,12 @@ export const invokePromiseInstanceMethod = (runner, promises, ref, args, node) =
     return chainReaction(runner, promises, ref.promise, onFulfilled, onRejected, method, node);
 };
 const constructPromise = (runner, promises, executor, node) => {
-    if (!(executor instanceof CodeModeFunction)) {
+    if (!(executor instanceof ProgramFunction)) {
         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 box = {};
-        const promise = yield* promises.create(Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, box)));
-        box.promise = promise;
+        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]));
@@ -223,20 +223,15 @@ const reactionExit = (promises, source) => Effect.gen(function* () {
     return exit;
 });
 const chainReaction = (runner, promises, source, onFulfilled, onRejected, method, node) => {
-    const box = {};
-    const body = Effect.gen(function* () {
+    return promises.createWithSelf((self) => Effect.gen(function* () {
         const exit = yield* reactionExit(promises, source);
         const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected;
         if (handler === undefined)
             return yield* exit;
         const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause));
         const result = yield* applyCollectionCallback(runner, handler, method, node)([input]);
-        return yield* resolvePromiseValue(runner, result, node, box);
-    });
-    return Effect.map(promises.create(body), (derived) => {
-        box.promise = derived;
-        return derived;
-    });
+        return yield* resolvePromiseValue(runner, result, node, self);
+    }));
 };
 const chainFinally = (runner, promises, source, cleanup, method, node) => promises.create(Effect.gen(function* () {
     const exit = yield* reactionExit(promises, source);

package/dist/interpreter/references.js

@@ -1,10 +1,11 @@
 import { ToolReference } from "../tool-runtime.js";
 import { Values } from "../values.js";
 import { HostFunction, HostNamespace } from "./host.js";
-import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, IteratorSymbol, PromiseInstanceMethodReference, } from "./model.js";
+import { CodeModeGenerator, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, PromiseInstanceMethodReference, } from "./model.js";
+import { getOwn, ownKeys, ProgramArray, ProgramFunction, ProgramObject } from "./objects.js";
 export const isRuntimeReference = (value) => value instanceof HostFunction ||
     value instanceof HostNamespace ||
-    value instanceof CodeModeFunction ||
+    value instanceof ProgramFunction ||
     value instanceof CodeModeGenerator ||
     value instanceof GeneratorMethodReference ||
     value instanceof ToolReference ||
@@ -13,13 +14,10 @@ export const isRuntimeReference = (value) => value instanceof HostFunction ||
     value instanceof Values.Promise ||
     Values.isValue(value);
 function* childValues(value) {
-    for (const key of Reflect.ownKeys(value)) {
-        if (!Object.prototype.propertyIsEnumerable.call(value, key))
-            continue;
-        if (typeof key === "symbol" && key !== AsyncIteratorSymbol && key !== IteratorSymbol)
-            continue;
-        yield Reflect.get(value, key);
-    }
+    if (!(value instanceof ProgramObject))
+        return;
+    for (const key of ownKeys(value))
+        yield getOwn(value, key);
 }
 // Depth-first search over a value tree. `match` stops the walk; `skip` prunes a subtree without matching it.
 const find = (value, match, skip, seen) => {
@@ -53,7 +51,7 @@ export const rejectCircularInsertion = (container, value, label, node, seen = ne
 export const describeValue = (value) => {
     if (value === null)
         return "null";
-    if (Array.isArray(value))
+    if (value instanceof ProgramArray)
         return "an array";
     if (value instanceof Values.Promise)
         return "an un-awaited Promise";
@@ -81,7 +79,7 @@ export const describeValue = (value) => {
 };
 export const typeofValue = (value) => {
     if (value instanceof HostFunction ||
-        value instanceof CodeModeFunction ||
+        value instanceof ProgramFunction ||
         value instanceof GeneratorMethodReference ||
         value instanceof IntrinsicReference ||
         value instanceof PromiseInstanceMethodReference) {

package/dist/interpreter/runner.d.ts

@@ -1,7 +1,8 @@
 import { Effect } from "effect";
 import { Values } from "../values.js";
 import { HostFunction } from "./host.js";
-import { type AstNode, CodeModeFunction, IntrinsicReference } from "./model.js";
+import { type AstNode, IntrinsicReference } from "./model.js";
+import { ProgramFunction } from "./objects.js";
 export type IteratorCursor<R> = {
     readonly next: Effect.Effect<{
         readonly done: boolean;
@@ -11,13 +12,13 @@ export type IteratorCursor<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 invokeFunction: (fn: ProgramFunction, 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 type SupportedCallback = ProgramFunction | 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

@@ -2,7 +2,8 @@ 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 { InterpreterRuntimeError, IntrinsicReference } from "./model.js";
+import { get, has, ProgramFunction, ProgramObject } from "./objects.js";
 import { typeofValue } from "./references.js";
 export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
     ? Effect.succeed(exit.value)
@@ -13,22 +14,24 @@ export const toPrimitive = (runner, value, hint, node) => {
     if (Values.isValue(value)) {
         return Effect.succeed(value instanceof Values.Date && hint === "number" ? value.time : coerceToString(value));
     }
-    const object = value;
+    if (!(value instanceof ProgramObject))
+        return Effect.succeed(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"))
+            if (method === "toString" && !has(value, "toString"))
                 return coerceToString(value);
-            if (!Object.hasOwn(object, method) || typeofValue(object[method]) !== "function")
+            const callable = get(value, method);
+            if (typeofValue(callable) !== "function")
                 continue;
-            const result = yield* runner.invokeCallable(object[method], [], node);
+            const result = yield* runner.invokeCallable(callable, [], 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 ||
+export const isSupportedCallback = (value) => value instanceof ProgramFunction ||
     (value instanceof HostFunction && value.callback) ||
     value instanceof IntrinsicReference;
 export const applyCollectionCallback = (runner, callback, name, node) => {

package/dist/interpreter/runtime.d.ts

@@ -1,5 +1,6 @@
 import type { Program } from "acorn";
 import { Effect } from "effect";
+import { type Host } from "./globals.js";
 import { type Runner } from "./runner.js";
 import { PromiseRuntime } from "./promises.js";
 /** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
@@ -13,6 +14,6 @@ export declare class Runtime<R> {
     /** Built-in globals by name, unaffected by program shadowing. */
     readonly builtins: ReadonlyMap<string, unknown>;
     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>);
+    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>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>);
     run(program: Program): Effect.Effect<unknown, unknown, R>;
 }