@opencode/codemode 2.0.2 → 2.0.4

package/dist/stdlib/object.d.ts

@@ -1,7 +1,7 @@
 import { type AstNode } from "../interpreter/model.js";
-import { ProgramObject } from "../interpreter/objects.js";
-import { type Runner } from "../interpreter/runner.js";
-export declare const enumerableSource: <R>(runner: Runner<R>, label: string, value: unknown, node: AstNode) => ProgramObject;
-export declare const objectAssign: <R>(runner: Runner<R>, args: Array<unknown>, node: AstNode) => unknown;
+import { Obj } from "../interpreter/objects.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const enumerableSource: <R>(ctx: Interpreter<R>, label: string, value: unknown, node?: AstNode) => Obj;
+export declare const objectAssign: <R>(ctx: Interpreter<R>, args: Array<unknown>) => unknown;
 export declare const classTag: (value: unknown) => string;
-export declare const objectGlobal: <R>(runner: Runner<R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>) => import("../interpreter/objects.js").NativeFunction<R>;
+export declare const objectGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/object.js

@@ -1,66 +1,65 @@
 import { Effect } from "effect";
-import { toProgram } from "../data.js";
 import { constructor, methods, receiver } from "../interpreter/native.js";
-import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol, rangeError, } from "../interpreter/model.js";
-import { Callable, define, entries, enumerableKeys, getOwn, hasOwn, hasPrototype, hidden, keys, own, ProgramArray, ProgramDate, ProgramError, ProgramObject, ProgramPromise, ProgramRegExp, set, } from "../interpreter/objects.js";
+import { AsyncIteratorSymbol, invalidData, IteratorSymbol, rangeError, typeError, } from "../interpreter/model.js";
+import { Callable, define, entries, enumerableKeys, getOwn, hasOwn, hasPrototype, hidden, keys, own, Arr, Bytes, DateObj, ErrorObj, Obj, PromiseObj, RegExpObj, set, } from "../interpreter/objects.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion } from "../interpreter/references.js";
-import { preserveConsumerError } from "../interpreter/runner.js";
+import { preserveConsumerError } from "../interpreter/callback.js";
 import { ToolReference } from "../tool-runtime.js";
 import { groupBy } from "./collections.js";
 import { coerceToString } from "./value.js";
 // ToObject for enumeration.
-export const enumerableSource = (runner, label, value, node) => {
+export const enumerableSource = (ctx, label, value, node) => {
     if (value === null || value === undefined) {
-        throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node);
+        throw typeError(`${label} cannot convert ${describeValue(value)} to an object.`, node);
     }
-    if (value instanceof ProgramPromise) {
-        throw new InterpreterRuntimeError(`${label} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
+    if (value instanceof PromiseObj) {
+        throw invalidData(`${label} received an un-awaited Promise; await it before inspecting the result.`, node);
     }
     if (value instanceof ToolReference) {
-        throw new InterpreterRuntimeError(`${label} cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node, "InvalidDataValue");
+        throw invalidData(`${label} cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node);
     }
     if (typeof value === "string")
-        return new ProgramArray(runner.prototypes.Array, [...value]);
-    if (value instanceof ProgramObject)
+        return new Arr(ctx.builtins.Array, [...value]);
+    if (value instanceof Obj)
         return value;
-    return new ProgramObject(runner.prototypes.Object);
+    return new Obj(ctx.builtins.Object);
 };
-export const objectAssign = (runner, args, node) => {
+export const objectAssign = (ctx, args) => {
     const target = args[0];
     // JS would box a primitive target; wrappers and primitives cannot hold fields here.
-    if (!(target instanceof ProgramObject)) {
-        throw new InterpreterRuntimeError(`Object.assign expects a data object or array target, received ${describeValue(target)}.`, node);
+    if (!(target instanceof Obj)) {
+        throw typeError(`Object.assign expects a data object or array target, received ${describeValue(target)}.`);
     }
     const seen = new Set();
     for (const source of args.slice(1)) {
         if (source === null || source === undefined)
             continue;
-        const from = enumerableSource(runner, "Object.assign(...)", source, node);
+        const from = enumerableSource(ctx, "Object.assign(...)", source);
         for (const key of enumerableKeys(from)) {
-            rejectCircularInsertion(target, getOwn(from, key), "Object.assign result", node, seen);
+            rejectCircularInsertion(target, getOwn(from, key), "Object.assign result", seen);
             if (!set(target, key, getOwn(from, key))) {
-                if (target instanceof ProgramArray && key === "length")
-                    throw rangeError("Invalid array length", node);
-                throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node);
+                if (target instanceof Arr && key === "length")
+                    throw rangeError("Invalid array length");
+                throw typeError(`Cannot assign to read only property '${String(key)}'.`);
             }
         }
     }
     return target;
 };
-const objectFromEntries = (runner, source, node) => {
-    const out = new ProgramObject(runner.prototypes.Object);
+const objectFromEntries = (ctx, source) => {
+    const out = new Obj(ctx.builtins.Object);
     return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(source, node);
+        const cursor = yield* ctx.iterate(source);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError("Object.fromEntries expects a synchronous iterable of entries.", node);
+            throw typeError("Object.fromEntries expects a synchronous iterable of entries.");
         }
         while (true) {
             const step = yield* cursor.next;
             if (step.done)
                 return out;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
-                if (!(step.value instanceof ProgramObject) || containsOpaqueReference(step.value)) {
-                    throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node);
+                if (!(step.value instanceof Obj) || containsOpaqueReference(step.value)) {
+                    throw typeError("Object.fromEntries expects [key, value] entry objects.");
                 }
                 define(out, coerceToString(getOwn(step.value, 0)), getOwn(step.value, 1));
             }));
@@ -72,16 +71,18 @@ export const classTag = (value) => {
         return "Null";
     if (value === undefined)
         return "Undefined";
-    if (value instanceof ProgramArray)
+    if (value instanceof Arr)
         return "Array";
     if (value instanceof Callable)
         return "Function";
-    if (value instanceof ProgramError)
+    if (value instanceof ErrorObj)
         return "Error";
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return "Date";
-    if (value instanceof ProgramRegExp)
+    if (value instanceof RegExpObj)
         return "RegExp";
+    if (value instanceof Bytes)
+        return "Uint8Array";
     if (typeof value === "string")
         return "String";
     if (typeof value === "number")
@@ -93,84 +94,80 @@ export const classTag = (value) => {
 const propertyKey = (value) => value === AsyncIteratorSymbol || value === IteratorSymbol ? value : coerceToString(value);
 // Object constructs identically with or without new, like JS. Only `keys` copies its result into the
 // program; `values`, `entries`, `assign`, and `fromEntries` hand back the program's own values.
-export const objectGlobal = (runner, toolKeys) => {
-    const protos = runner.prototypes;
-    const construct = (args, node) => {
+export const objectGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const construct = (args) => {
         const first = args[0];
         if (first === null || first === undefined)
-            return new ProgramObject(protos.Object);
-        if (typeof first === "object")
+            return new Obj(builtins.Object);
+        if (first instanceof Obj)
             return first;
-        throw new InterpreterRuntimeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`, node);
+        throw typeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`);
     };
-    const object = constructor(protos, protos.Object, {
+    const object = constructor(builtins, builtins.Object, {
         name: "Object",
         length: 1,
-        call: (_, args, node) => Effect.sync(() => construct(args, node)),
-        construct: (args, _, node) => Effect.sync(() => construct(args, node)),
+        call: (_, args) => Effect.sync(() => construct(args)),
+        construct: (args) => Effect.sync(() => construct(args)),
     });
-    methods(protos, object, [
+    methods(builtins, object, [
         [
             "keys",
             1,
-            (_, args, node) => toProgram(protos, args[0] instanceof ToolReference
-                ? [...toolKeys(args[0].path)]
-                : keys(enumerableSource(runner, "Object.keys(...)", args[0], node)), "Object.keys result"),
+            (_, args) => new Arr(builtins.Array, args[0] instanceof ToolReference
+                ? [...ctx.tools.keys(args[0].path)]
+                : keys(enumerableSource(ctx, "Object.keys(...)", args[0]))),
         ],
         [
             "values",
             1,
-            (_, args, node) => new ProgramArray(protos.Array, entries(enumerableSource(runner, "Object.values(...)", args[0], node)).map((entry) => entry[1])),
+            (_, args) => new Arr(builtins.Array, entries(enumerableSource(ctx, "Object.values(...)", args[0])).map((entry) => entry[1])),
         ],
         [
             "entries",
             1,
-            (_, args, node) => new ProgramArray(protos.Array, entries(enumerableSource(runner, "Object.entries(...)", args[0], node)).map((entry) => new ProgramArray(protos.Array, entry))),
-        ],
-        [
-            "hasOwn",
-            2,
-            (_, args, node) => hasOwn(enumerableSource(runner, "Object.hasOwn(...)", args[0], node), propertyKey(args[1])),
+            (_, args) => new Arr(builtins.Array, entries(enumerableSource(ctx, "Object.entries(...)", args[0])).map((entry) => new Arr(builtins.Array, entry))),
         ],
+        ["hasOwn", 2, (_, args) => hasOwn(enumerableSource(ctx, "Object.hasOwn(...)", args[0]), propertyKey(args[1]))],
         [
             "is",
             2,
-            (_, args, node) => {
+            (_, args) => {
                 if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
-                    throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue");
+                    throw invalidData("Object.is requires data values.");
                 }
                 return Object.is(args[0], args[1]);
             },
         ],
-        ["assign", 2, (_, args, node) => objectAssign(runner, args, node)],
-        ["fromEntries", 1, (_, args, node) => objectFromEntries(runner, args[0], node)],
+        ["assign", 2, (_, args) => objectAssign(ctx, args)],
+        ["fromEntries", 1, (_, args) => objectFromEntries(ctx, args[0])],
     ]);
-    define(object, "groupBy", groupBy(runner, "Object"), hidden);
-    methods(protos, protos.Object, [
+    define(object, "groupBy", groupBy(ctx, "Object"), hidden);
+    methods(builtins, builtins.Object, [
         [
             "hasOwnProperty",
             1,
-            (thisValue, args, node) => hasOwn(receiver(ProgramObject, thisValue, "Object.prototype.hasOwnProperty", node), propertyKey(args[0])),
+            (thisValue, args) => hasOwn(receiver(Obj, thisValue, "Object.prototype.hasOwnProperty"), propertyKey(args[0])),
         ],
         [
             "isPrototypeOf",
             1,
-            (thisValue, args, node) => hasPrototype(args[0], receiver(ProgramObject, thisValue, "Object.prototype.isPrototypeOf", node)),
+            (thisValue, args) => hasPrototype(args[0], receiver(Obj, thisValue, "Object.prototype.isPrototypeOf")),
         ],
         [
             "propertyIsEnumerable",
             1,
-            (thisValue, args, node) => own(receiver(ProgramObject, thisValue, "Object.prototype.propertyIsEnumerable", node), propertyKey(args[0]))
-                ?.enumerable === true,
+            (thisValue, args) => own(receiver(Obj, thisValue, "Object.prototype.propertyIsEnumerable"), propertyKey(args[0]))?.enumerable ===
+                true,
         ],
         ["toString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
         ["toLocaleString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
         [
             "valueOf",
             0,
-            (thisValue, _, node) => {
+            (thisValue) => {
                 if (thisValue === null || thisValue === undefined) {
-                    throw new InterpreterRuntimeError("Object.prototype.valueOf called on null or undefined.", node);
+                    throw typeError("Object.prototype.valueOf called on null or undefined.");
                 }
                 return thisValue;
             },

package/dist/stdlib/regexp.d.ts

@@ -1,8 +1,7 @@
-import type { Prototypes } from "../interpreter/intrinsics.js";
-import { type AstNode } from "../interpreter/model.js";
-import { ProgramArray, ProgramObject, ProgramRegExp } from "../interpreter/objects.js";
-import type { Runner } from "../interpreter/runner.js";
-export declare const toHostRegex: (arg: unknown, method: string, node: AstNode, extraFlags?: string) => RegExp;
-export declare const matchToValue: (protos: Prototypes, match: RegExpMatchArray) => ProgramArray;
-export declare const constructRegExp: (protos: Prototypes, args: Array<unknown>, node: AstNode, proto?: ProgramObject) => ProgramRegExp;
-export declare const regexpGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+import type { Builtins } from "../interpreter/intrinsics.js";
+import { Arr, Obj, RegExpObj } from "../interpreter/objects.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const toHostRegex: (arg: unknown, method: string, extraFlags?: string) => RegExp;
+export declare const matchToValue: (builtins: Builtins, match: RegExpMatchArray) => Arr;
+export declare const constructRegExp: (builtins: Builtins, args: Array<unknown>, proto?: Obj) => RegExpObj;
+export declare const regexpGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/regexp.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
-import { InterpreterRuntimeError, syntaxError } from "../interpreter/model.js";
-import { define, defineAccessor, getOwn, ProgramArray, ProgramObject, ProgramRegExp, record, set, } from "../interpreter/objects.js";
+import { syntaxError, typeError } from "../interpreter/model.js";
+import { define, defineAccessor, Arr, Obj, RegExpObj, record } from "../interpreter/objects.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 const flagProperties = [
     "hasIndices",
@@ -15,114 +15,106 @@ const flagProperties = [
 ];
 const regexFailureReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "");
 const escapeRegexHint = 'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.';
-export const toHostRegex = (arg, method, node, extraFlags = "") => {
+export const toHostRegex = (arg, method, extraFlags = "") => {
     // Native parity: an undefined pattern behaves as an empty pattern.
     if (arg === undefined)
         return new RegExp("", extraFlags);
-    if (arg instanceof ProgramRegExp)
+    if (arg instanceof RegExpObj)
         return arg.regex;
     if (typeof arg === "string") {
         try {
             return new RegExp(arg, extraFlags);
         }
         catch (error) {
-            throw syntaxError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`, node);
+            throw syntaxError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`);
         }
     }
-    throw new InterpreterRuntimeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`, node);
+    throw typeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`);
 };
-export const matchToValue = (protos, match) => {
-    const result = new ProgramArray(protos.Array, Array.from(match, (group) => group));
+export const matchToValue = (builtins, match) => {
+    const result = new Arr(builtins.Array, Array.from(match, (group) => group));
     if (match.index !== undefined)
         define(result, "index", match.index);
     if (match.input !== undefined)
         define(result, "input", match.input);
     if (match.groups)
-        define(result, "groups", record(protos.Object, match.groups));
+        define(result, "groups", record(builtins.Object, match.groups));
     if (match.indices)
-        define(result, "indices", indicesToValue(protos, match.indices));
+        define(result, "indices", indicesToValue(builtins, match.indices));
     return result;
 };
-export const constructRegExp = (protos, args, node, proto = protos.RegExp) => {
+export const constructRegExp = (builtins, args, proto = builtins.RegExp) => {
     const first = args[0];
-    const pattern = first instanceof ProgramRegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
+    const pattern = first instanceof RegExpObj ? first.regex.source : first === undefined ? "" : coerceToString(first);
     const flagsArg = args[1];
     if (flagsArg !== undefined && typeof flagsArg !== "string") {
-        throw syntaxError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node);
+        throw syntaxError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`);
     }
-    const flags = flagsArg ?? (first instanceof ProgramRegExp ? first.regex.flags : "");
+    const flags = flagsArg ?? (first instanceof RegExpObj ? first.regex.flags : "");
     try {
-        return new ProgramRegExp(proto, pattern, flags);
+        return new RegExpObj(proto, pattern, flags);
     }
     catch (error) {
         const reason = regexFailureReason(error);
         throw syntaxError(/flag/i.test(reason)
             ? `new RegExp(...) received invalid flags ${JSON.stringify(flags)} (${reason}). Valid flags are d, g, i, m, s, u, v, and y.`
-            : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`, node);
+            : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`);
     }
 };
-const toLength = (value) => {
-    const number = coerceToNumber(value);
-    if (Number.isNaN(number) || number <= 0)
-        return 0;
-    return Math.min(Math.floor(number), Number.MAX_SAFE_INTEGER);
-};
 // RegExp constructs identically with or without new, like JS.
-export const regexpGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.RegExp;
-    const regexp = constructor(protos, proto, {
+export const regexpGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.RegExp;
+    const regexp = constructor(builtins, proto, {
         name: "RegExp",
         length: 2,
-        call: (_, args, node) => Effect.sync(() => constructRegExp(protos, args, node)),
-        construct: (args, newTarget, node) => Effect.sync(() => constructRegExp(protos, args, node, prototypeFrom(newTarget, proto))),
+        call: (_, args) => Effect.sync(() => constructRegExp(builtins, args)),
+        construct: (args, newTarget) => Effect.sync(() => constructRegExp(builtins, args, prototypeFrom(newTarget, proto))),
     });
-    methods(protos, regexp, [
+    methods(builtins, regexp, [
         [
             "escape",
             1,
-            (_, args, node) => {
+            (_, args) => {
                 if (typeof args[0] !== "string")
-                    throw new InterpreterRuntimeError("RegExp.escape expects a string.", node);
+                    throw typeError("RegExp.escape expects a string.");
                 return RegExp.escape(args[0]);
             },
         ],
     ]);
-    const self = (thisValue, name, node) => receiver(ProgramRegExp, thisValue, `RegExp.prototype.${name}`, node);
+    const self = (thisValue, name) => receiver(RegExpObj, thisValue, `RegExp.prototype.${name}`);
     defineAccessor(proto, "source", (thisValue) => self(thisValue, "source").regex.source);
     defineAccessor(proto, "flags", (thisValue) => self(thisValue, "flags").regex.flags);
+    // The host regex holds the only lastIndex, so exec/test and the String methods share one counter.
+    defineAccessor(proto, "lastIndex", (thisValue) => self(thisValue, "lastIndex").regex.lastIndex, (thisValue, value) => {
+        self(thisValue, "lastIndex").regex.lastIndex = coerceToNumber(value);
+    });
     for (const name of flagProperties)
         defineAccessor(proto, name, (thisValue) => self(thisValue, name).regex[name]);
-    // exec/test run the host regex from the program-visible lastIndex and write it back only when g or y is set.
     const run = (name) => [
         name,
         1,
-        (thisValue, args, node) => {
-            const value = self(thisValue, name, node);
-            const input = coerceToString(args[0]);
-            const stateful = value.regex.global || value.regex.sticky;
-            value.regex.lastIndex = toLength(getOwn(value, "lastIndex"));
-            const matched = value.regex.exec(input);
-            if (stateful)
-                set(value, "lastIndex", value.regex.lastIndex);
+        (thisValue, args) => {
+            const value = self(thisValue, name);
+            const matched = value.regex.exec(coerceToString(args[0]));
             if (name === "test")
                 return matched !== null;
-            return matched === null ? null : matchToValue(protos, matched);
+            return matched === null ? null : matchToValue(builtins, matched);
         },
     ];
-    methods(protos, proto, [
+    methods(builtins, proto, [
         run("exec"),
         run("test"),
-        ["toString", 0, (thisValue, _, node) => coerceToString(self(thisValue, "toString", node))],
+        ["toString", 0, (thisValue) => coerceToString(self(thisValue, "toString"))],
     ]);
     return regexp;
 };
-const indicesToValue = (protos, indices) => {
-    const range = (pair) => pair === undefined ? undefined : new ProgramArray(protos.Array, [...pair]);
-    const result = new ProgramArray(protos.Array, Array.from(indices, range));
+const indicesToValue = (builtins, indices) => {
+    const range = (pair) => pair === undefined ? undefined : new Arr(builtins.Array, [...pair]);
+    const result = new Arr(builtins.Array, Array.from(indices, range));
     const groups = indices.groups;
     define(result, "groups", groups === undefined
         ? undefined
-        : record(protos.Object, Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
+        : record(builtins.Object, Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
     return result;
 };

package/dist/stdlib/string.d.ts

@@ -1,2 +1,2 @@
-import { type Runner } from "../interpreter/runner.js";
-export declare const stringGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const stringGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;