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

package/dist/stdlib/date.js

@@ -1,22 +1,22 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
 import { rangeError } from "../interpreter/model.js";
-import { ProgramDate, ProgramObject } from "../interpreter/objects.js";
-import { toPrimitive, toPrimitiveNumber } from "../interpreter/runner.js";
+import { DateObj, Obj } from "../interpreter/objects.js";
+import { toPrimitive, toPrimitiveNumber } from "../interpreter/callback.js";
 import { coerceToNumber, coerceToString } from "./value.js";
-const constructDate = (runner, args, proto) => {
+const constructDate = (ctx, args, proto) => {
     if (args.length === 0)
-        return Effect.succeed(new ProgramDate(proto, Date.now()));
+        return Effect.succeed(new DateObj(proto, Date.now()));
     if (args.length === 1) {
         const arg = args[0];
-        if (arg instanceof ProgramDate)
-            return Effect.succeed(new ProgramDate(proto, arg.time));
-        return Effect.map(toPrimitive(runner, arg, "default"), (value) => typeof value === "string"
-            ? new ProgramDate(proto, Date.parse(value))
-            : new ProgramDate(proto, new Date(coerceToNumber(value)).getTime()));
+        if (arg instanceof DateObj)
+            return Effect.succeed(new DateObj(proto, arg.time));
+        return Effect.map(toPrimitive(ctx, arg, "default"), (value) => typeof value === "string"
+            ? new DateObj(proto, Date.parse(value))
+            : new DateObj(proto, new Date(coerceToNumber(value)).getTime()));
     }
     const parts = args.map((arg) => coerceToNumber(arg));
-    return Effect.succeed(new ProgramDate(proto, new Date(...parts).getTime()));
+    return Effect.succeed(new DateObj(proto, new Date(...parts).getTime()));
 };
 const getters = [
     "getFullYear",
@@ -54,28 +54,28 @@ const setters = [
     ["setFullYear", 3],
     ["setUTCFullYear", 3],
 ];
-export const dateGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.Date;
-    const date = constructor(protos, proto, {
+export const dateGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.Date;
+    const date = constructor(builtins, proto, {
         name: "Date",
         length: 7,
         // ISO instead of the host's locale string: date strings are deterministic and must not leak the host timezone.
         call: () => Effect.sync(() => new Date().toISOString()),
-        construct: (args, newTarget) => constructDate(runner, args, prototypeFrom(newTarget, proto)),
+        construct: (args, newTarget) => constructDate(ctx, args, prototypeFrom(newTarget, proto)),
     });
-    methods(protos, date, [
+    methods(builtins, date, [
         ["now", 0, () => Date.now()],
         ["parse", 1, (_, args) => Date.parse(coerceToString(args[0]))],
         ["UTC", 7, (_, args) => Date.UTC(...args.map((arg) => coerceToNumber(arg)))],
     ]);
-    const self = (thisValue, name) => receiver(ProgramDate, thisValue, `Date.prototype.${name}`);
+    const self = (thisValue, name) => receiver(DateObj, thisValue, `Date.prototype.${name}`);
     const iso = (value) => {
         if (!Number.isFinite(value.time))
             throw rangeError("Invalid time value.");
         return new Date(value.time).toISOString();
     };
-    methods(protos, proto, [
+    methods(builtins, proto, [
         ["getTime", 0, (thisValue) => self(thisValue, "getTime").time],
         ["valueOf", 0, (thisValue) => self(thisValue, "valueOf").time],
         ["toISOString", 0, (thisValue) => iso(self(thisValue, "toISOString"))],
@@ -100,7 +100,7 @@ export const dateGlobal = (runner) => {
                 const target = self(thisValue, name);
                 // Native setters read the current time before argument coercion, whose callbacks may mutate the Date.
                 const hosted = new Date(target.time);
-                return Effect.map(Effect.forEach(args.slice(0, length), (arg) => toPrimitiveNumber(runner, arg), {
+                return Effect.map(Effect.forEach(args.slice(0, length), (arg) => toPrimitiveNumber(ctx, arg), {
                     concurrency: 1,
                 }), (values) => {
                     target.time = hosted[name](...values);

package/dist/stdlib/json.d.ts

@@ -1,3 +1,3 @@
-import { type Runner } from "../interpreter/runner.js";
-import { ProgramObject } from "../interpreter/objects.js";
-export declare const jsonGlobal: <R>(runner: Runner<R>) => ProgramObject;
+import type { Interpreter } from "../interpreter/interpreter.js";
+import { Obj } from "../interpreter/objects.js";
+export declare const jsonGlobal: <R>(ctx: Interpreter<R>) => Obj;

package/dist/stdlib/json.js

@@ -1,26 +1,26 @@
 import { Effect } from "effect";
 import { methods } from "../interpreter/native.js";
-import { applyCollectionCallback } from "../interpreter/runner.js";
+import { applyCollectionCallback } from "../interpreter/callback.js";
 import { checkStringLength } from "../interpreter/limits.js";
 import { syntaxError, typeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { fromData, toData, toProgram } from "../data.js";
-import { Callable, get, keys, ProgramArray, ProgramObject, record, remove, set } from "../interpreter/objects.js";
-export const jsonGlobal = (runner) => {
-    const json = new ProgramObject(runner.prototypes.Object);
-    methods(runner.prototypes, json, [
-        ["parse", 2, (_, args) => parse(runner, args)],
-        ["stringify", 3, (_, args) => stringify(runner, args)],
+import { Callable, get, keys, Arr, Obj, record, remove, set } from "../interpreter/objects.js";
+export const jsonGlobal = (ctx) => {
+    const json = new Obj(ctx.builtins.Object);
+    methods(ctx.builtins, json, [
+        ["parse", 2, (_, args) => parse(ctx, args)],
+        ["stringify", 3, (_, args) => stringify(ctx, args)],
     ]);
     return json;
 };
-const parse = (runner, args) => {
+const parse = (ctx, args) => {
     const text = args[0];
     if (typeof text !== "string")
         throw typeError("JSON.parse expects a string.");
     const parsed = (() => {
         try {
-            return fromData(runner.prototypes, JSON.parse(text), "JSON.parse result");
+            return fromData(ctx.builtins, JSON.parse(text), "JSON.parse result");
         }
         catch (error) {
             throw syntaxError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
@@ -28,10 +28,10 @@ const parse = (runner, args) => {
     })();
     if (typeofValue(args[1]) !== "function")
         return Effect.succeed(parsed);
-    const apply = applyCollectionCallback(runner, args[1], "JSON.parse");
+    const apply = applyCollectionCallback(ctx, args[1], "JSON.parse");
     const visit = (holder, key) => Effect.gen(function* () {
         const value = get(holder, key);
-        if (value instanceof ProgramObject) {
+        if (value instanceof Obj) {
             for (const name of keys(value)) {
                 const revived = yield* visit(value, name);
                 if (revived === undefined)
@@ -42,14 +42,14 @@ const parse = (runner, args) => {
         }
         return yield* apply([key, value]);
     });
-    return visit(record(runner.prototypes.Object, { "": parsed }), "");
+    return visit(record(ctx.builtins.Object, { "": parsed }), "");
 };
-const stringify = (runner, args) => {
+const stringify = (ctx, args) => {
     const space = args[2];
     const indent = typeof space === "number" || typeof space === "string" ? space : undefined;
     const replacer = args[1];
     if (typeofValue(replacer) !== "function") {
-        const properties = replacer instanceof ProgramArray
+        const properties = replacer instanceof Arr
             ? replacer.items
                 .filter((item) => typeof item === "string" || typeof item === "number")
                 .map(String)
@@ -61,24 +61,24 @@ const stringify = (runner, args) => {
         return Effect.succeed(text);
     }
     // Validate up front; the replacer walk below reads the original value.
-    toProgram(runner.prototypes, args[0], "JSON.stringify value");
-    const apply = applyCollectionCallback(runner, replacer, "JSON.stringify");
+    toProgram(ctx.builtins, args[0], "JSON.stringify value");
+    const apply = applyCollectionCallback(ctx, replacer, "JSON.stringify");
     const stack = new Set();
     const visit = (holder, key) => Effect.gen(function* () {
-        const value = yield* apply([key, yield* toJSONValue(runner, get(holder, key), key)]);
+        const value = yield* apply([key, yield* toJSONValue(ctx, get(holder, key), key)]);
         if (value === undefined || typeofValue(value) === "function")
             return undefined;
-        toProgram(runner.prototypes, value, "JSON.stringify replacer result");
+        toProgram(ctx.builtins, value, "JSON.stringify replacer result");
         if (typeof value === "number")
             return Number.isFinite(value) ? value : null;
         if (value === null || typeof value === "string" || typeof value === "boolean")
             return value;
-        if (!(value instanceof ProgramObject))
+        if (!(value instanceof Obj))
             return {};
         if (stack.has(value))
             throw typeError("Converting circular structure to JSON.");
         stack.add(value);
-        if (value instanceof ProgramArray) {
+        if (value instanceof Arr) {
             const result = [];
             for (let index = 0; index < value.items.length; index += 1) {
                 result.push((yield* visit(value, String(index))) ?? null);
@@ -95,12 +95,12 @@ const stringify = (runner, args) => {
         stack.delete(value);
         return result;
     });
-    return Effect.map(visit(record(runner.prototypes.Object, { "": args[0] }), ""), (value) => JSON.stringify(value, null, indent));
+    return Effect.map(visit(record(ctx.builtins.Object, { "": args[0] }), ""), (value) => JSON.stringify(value, null, indent));
 };
 // SerializeJSONProperty step 2: a callable `toJSON` decides the value, as Date and URL define.
-const toJSONValue = (runner, value, key) => {
-    if (!(value instanceof ProgramObject))
+const toJSONValue = (ctx, value, key) => {
+    if (!(value instanceof Obj))
         return Effect.succeed(value);
     const toJSON = get(value, "toJSON");
-    return toJSON instanceof Callable ? runner.invokeCallable(toJSON, value, [key]) : Effect.succeed(value);
+    return toJSON instanceof Callable ? ctx.call(toJSON, value, [key]) : Effect.succeed(value);
 };

package/dist/stdlib/math.d.ts

@@ -1,8 +1,8 @@
-import { ProgramObject } from "../interpreter/objects.js";
-import { type Runner } from "../interpreter/runner.js";
+import { Obj } from "../interpreter/objects.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
 declare global {
     interface Math {
         sumPrecise(values: Iterable<number>): number;
     }
 }
-export declare const mathGlobal: <R>(runner: Runner<R>) => ProgramObject;
+export declare const mathGlobal: <R>(ctx: Interpreter<R>) => Obj;

package/dist/stdlib/math.js

@@ -1,8 +1,8 @@
 import { Effect } from "effect";
 import { constants, methods } from "../interpreter/native.js";
 import { typeError } from "../interpreter/model.js";
-import { ProgramObject } from "../interpreter/objects.js";
-import { preserveConsumerError } from "../interpreter/runner.js";
+import { Obj } from "../interpreter/objects.js";
+import { preserveConsumerError } from "../interpreter/callback.js";
 // Validate only the arguments a method consumes; like JS, extras are ignored
 // (so built-ins work as callbacks receiving (element, index, array)).
 const number = (name, args, index) => {
@@ -28,9 +28,9 @@ const variadic = (name, op) => [
         return arg;
     })),
 ];
-export const mathGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const math = new ProgramObject(protos.Object);
+export const mathGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const math = new Obj(builtins.Object);
     constants(math, {
         PI: Math.PI,
         E: Math.E,
@@ -41,7 +41,7 @@ export const mathGlobal = (runner) => {
         SQRT2: Math.SQRT2,
         SQRT1_2: Math.SQRT1_2,
     });
-    methods(protos, math, [
+    methods(builtins, math, [
         ["random", 0, () => Math.random()],
         variadic("max", Math.max),
         variadic("min", Math.min),
@@ -82,7 +82,7 @@ export const mathGlobal = (runner) => {
             "sumPrecise",
             1,
             (_, args) => Effect.gen(function* () {
-                const cursor = yield* runner.syncIterator(args[0]);
+                const cursor = yield* ctx.iterate(args[0]);
                 if (cursor === undefined) {
                     throw typeError("Math.sumPrecise expects a synchronous iterable.");
                 }

package/dist/stdlib/number.d.ts

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

package/dist/stdlib/number.js

@@ -1,12 +1,12 @@
 import { constructor, constants, methods } from "../interpreter/native.js";
 import { rangeError, typeError } from "../interpreter/model.js";
 import { coercion, coerceToString } from "./value.js";
-export const numberGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const number = constructor(protos, protos.Number, {
+export const numberGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const number = constructor(builtins, builtins.Number, {
         name: "Number",
         length: 1,
-        call: coercion(runner, "Number").call,
+        call: coercion(ctx, "Number").call,
     });
     constants(number, {
         MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,
@@ -18,7 +18,7 @@ export const numberGlobal = (runner) => {
         POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
         NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
     });
-    methods(protos, number, [
+    methods(builtins, number, [
         ["isInteger", 1, (_, args) => Number.isInteger(args[0])],
         ["isFinite", 1, (_, args) => Number.isFinite(args[0])],
         ["isNaN", 1, (_, args) => Number.isNaN(args[0])],
@@ -48,7 +48,7 @@ export const numberGlobal = (runner) => {
             throw typeError(`Number.${name} expects a number argument.`);
         return arg;
     };
-    methods(protos, protos.Number, [
+    methods(builtins, builtins.Number, [
         ["toFixed", 1, (thisValue, args) => self(thisValue, "toFixed").toFixed(optNum("toFixed", args[0]))],
         [
             "toExponential",
@@ -80,19 +80,19 @@ export const numberGlobal = (runner) => {
     ]);
     return number;
 };
-export const booleanGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const boolean = constructor(protos, protos.Boolean, {
+export const booleanGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const boolean = constructor(builtins, builtins.Boolean, {
         name: "Boolean",
         length: 1,
-        call: coercion(runner, "Boolean").call,
+        call: coercion(ctx, "Boolean").call,
     });
     const self = (thisValue, name) => {
         if (typeof thisValue === "boolean")
             return thisValue;
         throw typeError(`Boolean.prototype.${name} requires that 'this' be a Boolean.`);
     };
-    methods(protos, protos.Boolean, [
+    methods(builtins, builtins.Boolean, [
         ["toString", 0, (thisValue) => String(self(thisValue, "toString"))],
         ["valueOf", 0, (thisValue) => self(thisValue, "valueOf")],
     ]);

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>) => 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

@@ -2,44 +2,44 @@ import { Effect } from "effect";
 import { toProgram } from "../data.js";
 import { constructor, methods, receiver } from "../interpreter/native.js";
 import { AsyncIteratorSymbol, invalidData, IteratorSymbol, rangeError, typeError, } 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 { 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 typeError(`${label} cannot convert ${describeValue(value)} to an object.`, node);
     }
-    if (value instanceof ProgramPromise) {
+    if (value instanceof PromiseObj) {
         throw invalidData(`${label} received an un-awaited Promise; await it before inspecting the result.`, node);
     }
     if (value instanceof ToolReference) {
         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) => {
+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)) {
+    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);
+        const from = enumerableSource(ctx, "Object.assign(...)", source);
         for (const key of enumerableKeys(from)) {
             rejectCircularInsertion(target, getOwn(from, key), "Object.assign result", seen);
             if (!set(target, key, getOwn(from, key))) {
-                if (target instanceof ProgramArray && key === "length")
+                if (target instanceof Arr && key === "length")
                     throw rangeError("Invalid array length");
                 throw typeError(`Cannot assign to read only property '${String(key)}'.`);
             }
@@ -47,10 +47,10 @@ export const objectAssign = (runner, args) => {
     }
     return target;
 };
-const objectFromEntries = (runner, source) => {
-    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);
+        const cursor = yield* ctx.iterate(source);
         if (cursor === undefined) {
             throw typeError("Object.fromEntries expects a synchronous iterable of entries.");
         }
@@ -59,7 +59,7 @@ const objectFromEntries = (runner, source) => {
             if (step.done)
                 return out;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
-                if (!(step.value instanceof ProgramObject) || containsOpaqueReference(step.value)) {
+                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 +72,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,41 +95,41 @@ 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;
+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 (first instanceof ProgramObject)
+            return new Obj(builtins.Object);
+        if (first instanceof Obj)
             return first;
         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) => Effect.sync(() => construct(args)),
         construct: (args) => Effect.sync(() => construct(args)),
     });
-    methods(protos, object, [
+    methods(builtins, object, [
         [
             "keys",
             1,
-            (_, args) => toProgram(protos, args[0] instanceof ToolReference
-                ? [...toolKeys(args[0].path)]
-                : keys(enumerableSource(runner, "Object.keys(...)", args[0])), "Object.keys result"),
+            (_, args) => toProgram(builtins, args[0] instanceof ToolReference
+                ? [...ctx.tools.keys(args[0].path)]
+                : keys(enumerableSource(ctx, "Object.keys(...)", args[0])), "Object.keys result"),
         ],
         [
             "values",
             1,
-            (_, args) => new ProgramArray(protos.Array, entries(enumerableSource(runner, "Object.values(...)", args[0])).map((entry) => entry[1])),
+            (_, args) => new Arr(builtins.Array, entries(enumerableSource(ctx, "Object.values(...)", args[0])).map((entry) => entry[1])),
         ],
         [
             "entries",
             1,
-            (_, args) => new ProgramArray(protos.Array, entries(enumerableSource(runner, "Object.entries(...)", args[0])).map((entry) => new ProgramArray(protos.Array, entry))),
+            (_, args) => new Arr(builtins.Array, entries(enumerableSource(ctx, "Object.entries(...)", args[0])).map((entry) => new Arr(builtins.Array, entry))),
         ],
-        ["hasOwn", 2, (_, args) => hasOwn(enumerableSource(runner, "Object.hasOwn(...)", args[0]), propertyKey(args[1]))],
+        ["hasOwn", 2, (_, args) => hasOwn(enumerableSource(ctx, "Object.hasOwn(...)", args[0]), propertyKey(args[1]))],
         [
             "is",
             2,
@@ -138,26 +140,26 @@ export const objectGlobal = (runner, toolKeys) => {
                 return Object.is(args[0], args[1]);
             },
         ],
-        ["assign", 2, (_, args) => objectAssign(runner, args)],
-        ["fromEntries", 1, (_, args) => objectFromEntries(runner, args[0])],
+        ["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) => hasOwn(receiver(ProgramObject, thisValue, "Object.prototype.hasOwnProperty"), propertyKey(args[0])),
+            (thisValue, args) => hasOwn(receiver(Obj, thisValue, "Object.prototype.hasOwnProperty"), propertyKey(args[0])),
         ],
         [
             "isPrototypeOf",
             1,
-            (thisValue, args) => hasPrototype(args[0], receiver(ProgramObject, thisValue, "Object.prototype.isPrototypeOf")),
+            (thisValue, args) => hasPrototype(args[0], receiver(Obj, thisValue, "Object.prototype.isPrototypeOf")),
         ],
         [
             "propertyIsEnumerable",
             1,
-            (thisValue, args) => own(receiver(ProgramObject, thisValue, "Object.prototype.propertyIsEnumerable"), 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)}]`],

package/dist/stdlib/regexp.d.ts

@@ -1,7 +1,7 @@
-import type { Prototypes } from "../interpreter/intrinsics.js";
-import { ProgramArray, ProgramObject, ProgramRegExp } from "../interpreter/objects.js";
-import type { Runner } from "../interpreter/runner.js";
+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: (protos: Prototypes, match: RegExpMatchArray) => ProgramArray;
-export declare const constructRegExp: (protos: Prototypes, args: Array<unknown>, proto?: ProgramObject) => ProgramRegExp;
-export declare const regexpGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+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>;