@opencode/codemode 0.0.0-dev-19631 → 0.0.0-dev-19633

package/dist/interpreter/extensions.js

@@ -2,9 +2,9 @@ import { Effect } from "effect";
 import { MAX_VALUE_DEPTH } from "../data.js";
 import { coerceToString } from "../stdlib/value.js";
 import { createErrorValue, isErrorType } from "./intrinsics.js";
-import { ProgramThrow, typeError } from "./model.js";
+import { Throw, typeError } from "./model.js";
 import { constructor, fn } from "./native.js";
-import { Callable, define, defineAccessor, entries, get, hidden, ProgramArray, ProgramDate, ProgramError, ProgramGenerator, ProgramHandle, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./objects.js";
+import { Callable, define, defineAccessor, entries, get, hidden, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, Handle, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
 import { describeValue } from "./references.js";
 const isClass = (value) => typeof value === "function" && typeof value.prototype === "object" && value.prototype !== null;
 // Own keys the native function already carries.
@@ -15,11 +15,11 @@ const ownPrototypeKeys = new Set(["constructor"]);
  * copied, built-in wrappers are copied, instances of exposed classes travel as handles, and a host Promise becomes
  * a program promise. Prototypes, constructors, and handle identity are all per run.
  */
-export const extensionGlobals = (host, extensions) => {
-    const protos = host.runner.prototypes;
+export const extensionGlobals = (ctx, extensions) => {
+    const builtins = ctx.builtins;
     const classes = new Set(extensions.flatMap((extension) => Object.values(extension.globals)).filter(isClass));
     // Host prototype object → this run's program prototype, so an instance wraps as its most-derived exposed class.
-    const prototypes = new Map();
+    const protoOf = new Map();
     const exposed = new Map();
     const classOf = new Map();
     const handles = new WeakMap();
@@ -31,28 +31,30 @@ export const extensionGlobals = (host, extensions) => {
                 return value;
             throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
         }
-        if (value instanceof ProgramHandle)
+        if (value instanceof Handle)
             return value.instance;
-        if (value instanceof ProgramDate)
+        if (value instanceof Bytes)
+            return new Uint8Array(value.bytes);
+        if (value instanceof DateObj)
             return new Date(value.time);
-        if (value instanceof ProgramRegExp)
+        if (value instanceof RegExpObj)
             return new RegExp(value.regex.source, value.regex.flags);
-        if (value instanceof ProgramURL)
+        if (value instanceof URLObj)
             return new URL(value.url.href);
-        if (value instanceof ProgramURLSearchParams)
+        if (value instanceof URLSearchParamsObj)
             return new URLSearchParams(value.params);
         const next = (item) => toHost(item, label, depth + 1, seen);
-        if (value instanceof ProgramMap)
+        if (value instanceof MapObj)
             return new Map([...value.map].map(([key, item]) => [next(key), next(item)]));
-        if (value instanceof ProgramSet)
+        if (value instanceof SetObj)
             return new Set([...value.set].map(next));
-        if (!(value instanceof ProgramObject) ||
+        if (!(value instanceof Obj) ||
             value instanceof Callable ||
-            value instanceof ProgramGenerator ||
-            value instanceof ProgramPromise) {
+            value instanceof GeneratorObj ||
+            value instanceof PromiseObj) {
             throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
         }
-        if (value instanceof ProgramError) {
+        if (value instanceof ErrorObj) {
             const name = coerceToString(get(value, "name"));
             const message = get(value, "message");
             const text = message === undefined ? "" : coerceToString(message);
@@ -61,7 +63,7 @@ export const extensionGlobals = (host, extensions) => {
         if (seen.has(value))
             throw typeError(`${label} contains a circular value.`);
         seen.add(value);
-        const copied = value instanceof ProgramArray
+        const copied = value instanceof Arr
             ? value.items.map(next)
             : Object.fromEntries(entries(value)
                 .filter(([key]) => key !== "__proto__")
@@ -80,31 +82,35 @@ export const extensionGlobals = (host, extensions) => {
                 return existing;
             const proto = handlePrototype(value);
             if (proto !== undefined) {
-                const handle = new ProgramHandle(proto, value);
+                const handle = new Handle(proto, value);
                 handles.set(value, handle);
                 return handle;
             }
             if (value instanceof Date)
-                return new ProgramDate(protos.Date, value.getTime());
+                return new DateObj(builtins.Date, value.getTime());
             if (value instanceof RegExp)
-                return new ProgramRegExp(protos.RegExp, value.source, value.flags);
+                return new RegExpObj(builtins.RegExp, value.source, value.flags);
+            if (value instanceof Uint8Array)
+                return new Bytes(builtins.Uint8Array, new Uint8Array(value));
+            if (value instanceof ArrayBuffer)
+                return new Bytes(builtins.Uint8Array, new Uint8Array(value.slice(0)));
             if (value instanceof Error) {
-                return createErrorValue(protos[isErrorType(value.name) ? value.name : "Error"], value.message);
+                return createErrorValue(builtins[isErrorType(value.name) ? value.name : "Error"], value.message);
             }
             if (value instanceof URL)
-                return new ProgramURL(protos.URL, protos.URLSearchParams, new URL(value.href));
+                return new URLObj(builtins.URL, builtins.URLSearchParams, new URL(value.href));
             if (value instanceof URLSearchParams) {
-                return new ProgramURLSearchParams(protos.URLSearchParams, new URLSearchParams(value));
+                return new URLSearchParamsObj(builtins.URLSearchParams, new URLSearchParams(value));
             }
             const next = (item) => fromHost(item, label, depth + 1, seen);
             if (value instanceof Map) {
-                const wrapped = new ProgramMap(protos.Map);
+                const wrapped = new MapObj(builtins.Map);
                 for (const [key, item] of value)
                     wrapped.map.set(next(key), next(item));
                 return wrapped;
             }
             if (value instanceof Set) {
-                const wrapped = new ProgramSet(protos.Set);
+                const wrapped = new SetObj(builtins.Set);
                 for (const item of value)
                     wrapped.set.add(next(item));
                 return wrapped;
@@ -113,13 +119,13 @@ export const extensionGlobals = (host, extensions) => {
                 throw typeError(`${label} produced a circular value.`);
             seen.add(value);
             if (Array.isArray(value)) {
-                const copied = new ProgramArray(protos.Array, value.map(next));
+                const copied = new Arr(builtins.Array, value.map(next));
                 seen.delete(value);
                 return copied;
             }
             const prototype = Object.getPrototypeOf(value);
             if (prototype === Object.prototype || prototype === null) {
-                const copied = new ProgramObject(protos.Object);
+                const copied = new Obj(builtins.Object);
                 for (const [key, item] of Object.entries(value))
                     define(copied, key, next(item));
                 seen.delete(value);
@@ -130,7 +136,7 @@ export const extensionGlobals = (host, extensions) => {
     };
     const handlePrototype = (instance) => {
         for (let level = Object.getPrototypeOf(instance); level !== null; level = Object.getPrototypeOf(level)) {
-            const proto = prototypes.get(level);
+            const proto = protoOf.get(level);
             if (proto !== undefined)
                 return proto;
         }
@@ -139,7 +145,7 @@ export const extensionGlobals = (host, extensions) => {
     // Runs host code with already-converted inputs. Whatever it returns, resolves, throws, or rejects with crosses
     // the same way, so the program catches what the author threw.
     const invoke = (run, label) => {
-        const thrown = (reason) => new ProgramThrow(fromHost(reason, label));
+        const thrown = (reason) => new Throw(fromHost(reason, label));
         let result;
         try {
             result = run();
@@ -149,7 +155,7 @@ export const extensionGlobals = (host, extensions) => {
         }
         if (!(result instanceof Promise))
             return Effect.succeed(fromHost(result, label));
-        return host.promises.create(Effect.map(Effect.tryPromise({ try: () => result, catch: thrown }), (settled) => fromHost(settled, label)));
+        return ctx.pending.create(Effect.map(Effect.tryPromise({ try: () => result, catch: thrown }), (settled) => fromHost(settled, label)));
     };
     const args = (values, label) => values.map((value, index) => toHost(value, `Argument ${index + 1} to ${label}`));
     // Own members of each level from `from` up to (excluding) `root`, child first, as JS resolves them.
@@ -166,7 +172,7 @@ export const extensionGlobals = (host, extensions) => {
                         const converted = args(values, name);
                         return invoke(() => method.apply(self, converted), name);
                     };
-                    define(target, key, fn(protos, key, method.length, impl), hidden);
+                    define(target, key, fn(builtins, key, method.length, impl), hidden);
                     continue;
                 }
                 // Data properties stay host-side: a program write to one would change the host class itself.
@@ -195,10 +201,10 @@ export const extensionGlobals = (host, extensions) => {
             return existing;
         const ancestor = exposedAncestor(cls);
         const base = ancestor === undefined ? undefined : expose(ancestor);
-        const proto = new ProgramObject(base === undefined ? protos.Object : base.proto);
-        prototypes.set(cls.prototype, proto);
+        const proto = new Obj(base === undefined ? builtins.Object : base.proto);
+        protoOf.set(cls.prototype, proto);
         const name = cls.name;
-        const ctor = constructor(protos, proto, {
+        const ctor = constructor(builtins, proto, {
             name,
             length: cls.length,
             call: (_, values) => {
@@ -223,7 +229,7 @@ export const extensionGlobals = (host, extensions) => {
             return called !== undefined && (called === cls || called.prototype instanceof cls) ? called : cls;
         });
         members(proto, cls.prototype, ancestor?.prototype ?? Object.prototype, ownPrototypeKeys, `${name}.prototype`, (thisValue, member) => {
-            if (thisValue instanceof ProgramHandle && thisValue.instance instanceof cls)
+            if (thisValue instanceof Handle && thisValue.instance instanceof cls)
                 return thisValue.instance;
             throw typeError(`Illegal invocation: ${member} called on ${describeValue(thisValue)}.`);
         });
@@ -243,7 +249,7 @@ export const extensionGlobals = (host, extensions) => {
             const converted = args(values, name);
             return invoke(() => value.apply(undefined, converted), name);
         };
-        return [name, fn(protos, name, value.length, impl)];
+        return [name, fn(builtins, name, value.length, impl)];
     }));
 };
 const hostErrors = {

package/dist/interpreter/generators.d.ts

@@ -1,4 +1,3 @@
-import type { PromiseRuntime } from "./promises.js";
-import type { Runner } from "./runner.js";
+import type { Interpreter } from "./interpreter.js";
 /** `next`/`return`/`throw` on the generator prototypes; async generators answer with promises. */
-export declare const generatorGlobals: <R>(runner: Runner<R>, promises: PromiseRuntime<R>) => void;
+export declare const generatorGlobals: <R>(ctx: Interpreter<R>) => void;

package/dist/interpreter/generators.js

@@ -1,24 +1,24 @@
 import { Effect } from "effect";
 import { fn, methods, receiver } from "./native.js";
 import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
-import { define, hidden, ProgramGenerator } from "./objects.js";
+import { define, hidden, GeneratorObj } from "./objects.js";
 /** `next`/`return`/`throw` on the generator prototypes; async generators answer with promises. */
-export const generatorGlobals = (runner, promises) => {
-    const protos = runner.prototypes;
+export const generatorGlobals = (ctx) => {
+    const builtins = ctx.builtins;
     const install = (asynchronous) => {
-        const proto = asynchronous ? protos.AsyncGenerator : protos.Generator;
+        const proto = asynchronous ? builtins.AsyncGenerator : builtins.Generator;
         const label = asynchronous ? "AsyncGenerator" : "Generator";
         const request = (kind) => [
             kind,
             1,
             (thisValue, args) => {
-                const generator = receiver(ProgramGenerator, thisValue, `${label}.prototype.${kind}`);
+                const generator = receiver(GeneratorObj, thisValue, `${label}.prototype.${kind}`);
                 const requested = generator.request(kind, args[0]);
-                return generator.asynchronous ? promises.create(requested) : requested;
+                return generator.asynchronous ? ctx.pending.create(requested) : requested;
             },
         ];
-        methods(protos, proto, [request("next"), request("return"), request("throw")]);
-        define(asynchronous ? protos.AsyncIterator : protos.Iterator, asynchronous ? AsyncIteratorSymbol : IteratorSymbol, fn(protos, asynchronous ? "[Symbol.asyncIterator]" : "[Symbol.iterator]", 0, (thisValue) => thisValue), hidden);
+        methods(builtins, proto, [request("next"), request("return"), request("throw")]);
+        define(asynchronous ? builtins.AsyncIterator : builtins.Iterator, asynchronous ? AsyncIteratorSymbol : IteratorSymbol, fn(builtins, asynchronous ? "[Symbol.asyncIterator]" : "[Symbol.iterator]", 0, (thisValue) => thisValue), hidden);
     };
     install(false);
     install(true);

package/dist/interpreter/globals.d.ts

@@ -1,15 +1,5 @@
-import { Effect } from "effect";
-import { type PromiseRuntime } from "./promises.js";
-import type { Runner } from "./runner.js";
-/** What the built-in globals need from the interpreter that owns them. */
-export type Host<R> = {
-    readonly runner: Runner<R>;
-    readonly promises: PromiseRuntime<R>;
-    readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
-    readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
-    readonly logs: Array<string>;
-};
+import type { Interpreter } from "./interpreter.js";
 /** Names bound in every program before extensions apply. */
 export declare const globalNames: ReadonlySet<string>;
 /** The immutable global bindings of every program, in declaration order. */
-export declare const globals: <R>(host: Host<R>) => ReadonlyArray<readonly [string, unknown]>;
+export declare const globals: <R>(ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>;

package/dist/interpreter/globals.js

@@ -1,5 +1,6 @@
 import { Effect } from "effect";
 import { arrayGlobal } from "../stdlib/array.js";
+import { textDecoderGlobal, textEncoderGlobal, uint8ArrayGlobal } from "../stdlib/bytes.js";
 import { mapGlobal, setGlobal } from "../stdlib/collections.js";
 import { consoleGlobal } from "../stdlib/console.js";
 import { dateGlobal } from "../stdlib/date.js";
@@ -20,19 +21,19 @@ import { AsyncIteratorSymbol, IteratorSymbol, typeError } from "./model.js";
 import { generatorGlobals } from "./generators.js";
 import { promiseGlobal } from "./promises.js";
 // Function.prototype.constructor exists so `fn.constructor === Function` holds; dynamic code is unsupported.
-const functionGlobal = (runner) => {
+const functionGlobal = (ctx) => {
     const reject = () => Effect.sync(() => {
         throw typeError("The Function constructor is not supported; write the function inline.");
     });
-    return constructor(runner.prototypes, runner.prototypes.Function, {
+    return constructor(ctx.builtins, ctx.builtins.Function, {
         name: "Function",
         length: 1,
         call: reject,
         construct: reject,
     });
 };
-const symbolGlobal = (runner) => {
-    const symbol = native(runner.prototypes, {
+const symbolGlobal = (ctx) => {
+    const symbol = native(ctx.builtins, {
         name: "Symbol",
         call: () => Effect.sync(() => {
             throw typeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.");
@@ -45,44 +46,47 @@ const symbolGlobal = (runner) => {
 // A table rather than a list so the names are known before any runtime exists.
 const table = {
     tools: () => new ToolReference([]),
-    search: (host) => native(host.runner.prototypes, { name: "search", call: (_, args) => host.search(args), callback: false }),
+    search: (ctx) => native(ctx.builtins, { name: "search", call: (_, args) => ctx.tools.search(args), callback: false }),
     undefined: () => undefined,
     NaN: () => NaN,
     Infinity: () => Infinity,
-    Object: (host) => objectGlobal(host.runner, host.toolKeys),
-    Function: (host) => functionGlobal(host.runner),
-    Array: (host) => arrayGlobal(host.runner),
-    Math: (host) => mathGlobal(host.runner),
-    JSON: (host) => jsonGlobal(host.runner),
-    console: (host) => consoleGlobal(host.runner, host.logs),
-    Promise: (host) => promiseGlobal(host.runner, host.promises),
-    Symbol: (host) => symbolGlobal(host.runner),
-    Number: (host) => numberGlobal(host.runner),
-    String: (host) => stringGlobal(host.runner),
-    Boolean: (host) => booleanGlobal(host.runner),
-    parseInt: (host) => coercion(host.runner, "parseInt", 2),
-    parseFloat: (host) => coercion(host.runner, "parseFloat"),
-    isFinite: (host) => coercion(host.runner, "isFinite"),
-    isNaN: (host) => coercion(host.runner, "isNaN"),
-    Date: (host) => dateGlobal(host.runner),
-    RegExp: (host) => regexpGlobal(host.runner),
-    Map: (host) => mapGlobal(host.runner),
-    Set: (host) => setGlobal(host.runner),
-    URL: (host) => urlGlobal(host.runner),
-    URLSearchParams: (host) => urlSearchParamsGlobal(host.runner),
-    encodeURI: (host) => uriGlobal(host.runner, "encodeURI"),
-    encodeURIComponent: (host) => uriGlobal(host.runner, "encodeURIComponent"),
-    decodeURI: (host) => uriGlobal(host.runner, "decodeURI"),
-    decodeURIComponent: (host) => uriGlobal(host.runner, "decodeURIComponent"),
-    atob: (host) => base64Global(host.runner, "atob"),
-    btoa: (host) => base64Global(host.runner, "btoa"),
-    crypto: (host) => cryptoGlobal(host.runner),
-    ...Object.fromEntries(errorTypes.map((type) => [type, (host) => errorGlobal(type, host.runner)])),
+    Object: (ctx) => objectGlobal(ctx),
+    Function: (ctx) => functionGlobal(ctx),
+    Array: (ctx) => arrayGlobal(ctx),
+    Math: (ctx) => mathGlobal(ctx),
+    JSON: (ctx) => jsonGlobal(ctx),
+    console: (ctx) => consoleGlobal(ctx),
+    Promise: (ctx) => promiseGlobal(ctx),
+    Symbol: (ctx) => symbolGlobal(ctx),
+    Number: (ctx) => numberGlobal(ctx),
+    String: (ctx) => stringGlobal(ctx),
+    Boolean: (ctx) => booleanGlobal(ctx),
+    parseInt: (ctx) => coercion(ctx, "parseInt", 2),
+    parseFloat: (ctx) => coercion(ctx, "parseFloat"),
+    isFinite: (ctx) => coercion(ctx, "isFinite"),
+    isNaN: (ctx) => coercion(ctx, "isNaN"),
+    Date: (ctx) => dateGlobal(ctx),
+    RegExp: (ctx) => regexpGlobal(ctx),
+    Map: (ctx) => mapGlobal(ctx),
+    Set: (ctx) => setGlobal(ctx),
+    URL: (ctx) => urlGlobal(ctx),
+    URLSearchParams: (ctx) => urlSearchParamsGlobal(ctx),
+    Uint8Array: (ctx) => uint8ArrayGlobal(ctx),
+    TextEncoder: (ctx) => textEncoderGlobal(ctx),
+    TextDecoder: (ctx) => textDecoderGlobal(ctx),
+    encodeURI: (ctx) => uriGlobal(ctx, "encodeURI"),
+    encodeURIComponent: (ctx) => uriGlobal(ctx, "encodeURIComponent"),
+    decodeURI: (ctx) => uriGlobal(ctx, "decodeURI"),
+    decodeURIComponent: (ctx) => uriGlobal(ctx, "decodeURIComponent"),
+    atob: (ctx) => base64Global(ctx, "atob"),
+    btoa: (ctx) => base64Global(ctx, "btoa"),
+    crypto: (ctx) => cryptoGlobal(ctx),
+    ...Object.fromEntries(errorTypes.map((type) => [type, (ctx) => errorGlobal(type, ctx)])),
 };
 /** Names bound in every program before extensions apply. */
 export const globalNames = new Set(Object.keys(table));
 /** The immutable global bindings of every program, in declaration order. */
-export const globals = (host) => {
-    generatorGlobals(host.runner, host.promises);
-    return Object.entries(table).map(([name, factory]) => [name, factory(host)]);
+export const globals = (ctx) => {
+    generatorGlobals(ctx);
+    return Object.entries(table).map(([name, factory]) => [name, factory(ctx)]);
 };

package/dist/interpreter/interpreter.d.ts

@@ -0,0 +1,31 @@
+import type { Program } from "acorn";
+import { Effect } from "effect";
+import { type ToolRuntime } from "../tool-runtime.js";
+import type { Builtins } from "./intrinsics.js";
+import { PromiseObj } from "./objects.js";
+import { Pending } from "./promises.js";
+/** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
+export declare class Interpreter<R> {
+    readonly tools: ToolRuntime<R>;
+    readonly pending: Pending<R>;
+    readonly builtins: Builtins;
+    readonly logs: Array<string>;
+    private readonly root;
+    constructor(options: {
+        readonly tools: ToolRuntime<R>;
+        readonly pending: Pending<R>;
+        readonly builtins: Builtins;
+        readonly logs?: Array<string>;
+        readonly globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>;
+    });
+    run(program: Program): Effect.Effect<unknown, unknown, R>;
+    call(callable: unknown, thisValue: unknown, args: Array<unknown>): Effect.Effect<unknown, unknown, R>;
+    await(promise: PromiseObj): Effect.Effect<unknown, unknown, never>;
+    iterate(value: unknown): Effect.Effect<{
+        next: Effect.Effect<{
+            done: boolean;
+            value: unknown;
+        }, unknown, R>;
+        close: Effect.Effect<void, unknown, R>;
+    } | undefined, unknown, R>;
+}