@opencode/codemode 2.0.2 → 2.0.4

package/dist/stdlib/bytes.js

@@ -0,0 +1,228 @@
+import { Effect } from "effect";
+import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
+import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
+import { rangeError, syntaxError, typeError } from "../interpreter/model.js";
+import { defineAccessor, get, Arr, Bytes, Obj } from "../interpreter/objects.js";
+import { describeValue } from "../interpreter/references.js";
+import { coerceToNumber, coerceToString } from "./value.js";
+/** The bytes a Uint8Array, array, or other iterable of numbers describes; the host array clamps each value. */
+const collectBytes = (ctx, source, name) => {
+    if (source instanceof Bytes)
+        return Effect.succeed(new Uint8Array(source.bytes));
+    return Effect.gen(function* () {
+        const cursor = yield* ctx.iterate(source);
+        if (cursor === undefined) {
+            throw typeError(`${name} expects a Uint8Array, an array, or an iterable of numbers, received ${describeValue(source)}.`);
+        }
+        const values = [];
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return Uint8Array.from(values);
+            values.push(coerceToNumber(step.value));
+            checkArrayLength(values.length);
+        }
+    });
+};
+const constructBytes = (ctx, args, proto) => {
+    const source = args[0];
+    if (source !== null && typeof source === "object") {
+        return Effect.map(collectBytes(ctx, source, "new Uint8Array(...)"), (bytes) => new Bytes(proto, bytes));
+    }
+    const length = source === undefined ? 0 : coerceToNumber(source);
+    if (!Number.isInteger(length) || length < 0)
+        throw rangeError(`Invalid typed array length: ${coerceToString(source)}`);
+    checkArrayLength(length);
+    return Effect.succeed(new Bytes(proto, new Uint8Array(length)));
+};
+export const uint8ArrayGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.Uint8Array;
+    const wrap = (bytes) => new Bytes(proto, bytes);
+    const uint8Array = constructor(builtins, proto, {
+        name: "Uint8Array",
+        length: 3,
+        call: requiresNew("Uint8Array"),
+        construct: (args, newTarget) => constructBytes(ctx, args, prototypeFrom(newTarget, proto)),
+    });
+    const decode = (name, args, from) => {
+        if (typeof args[0] !== "string")
+            throw typeError(`Uint8Array.${name} expects a string.`);
+        try {
+            return wrap(from(args[0]));
+        }
+        catch {
+            throw syntaxError(`Uint8Array.${name}: the string is not valid ${name === "fromHex" ? "hex" : "base64"}.`);
+        }
+    };
+    methods(builtins, uint8Array, [
+        ["from", 1, (_, args) => Effect.map(collectBytes(ctx, args[0], "Uint8Array.from"), wrap)],
+        ["of", 0, (_, args) => wrap(Uint8Array.from(args, coerceToNumber))],
+        ["fromBase64", 1, (_, args) => decode("fromBase64", args, (text) => Uint8Array.fromBase64(text))],
+        ["fromHex", 1, (_, args) => decode("fromHex", args, (text) => Uint8Array.fromHex(text))],
+    ]);
+    const self = (thisValue, name) => receiver(Bytes, thisValue, `Uint8Array.prototype.${name}`);
+    const optNumber = (name, value, label) => {
+        if (value === undefined)
+            return undefined;
+        if (typeof value !== "number")
+            throw typeError(`Uint8Array.${name} expects ${label} to be a number.`);
+        return value;
+    };
+    const wrapAll = (items) => new Arr(builtins.Array, items);
+    defineAccessor(proto, "length", (thisValue) => self(thisValue, "length").bytes.length);
+    methods(builtins, proto, [
+        ["at", 1, (thisValue, args) => self(thisValue, "at").bytes.at(optNumber("at", args[0], "index") ?? 0)],
+        [
+            "slice",
+            2,
+            (thisValue, args) => wrap(self(thisValue, "slice").bytes.slice(optNumber("slice", args[0], "start"), optNumber("slice", args[1], "end"))),
+        ],
+        // A view on the same bytes, as in JS: writes through one are visible through the other.
+        [
+            "subarray",
+            2,
+            (thisValue, args) => wrap(self(thisValue, "subarray").bytes.subarray(optNumber("subarray", args[0], "start"), optNumber("subarray", args[1], "end"))),
+        ],
+        [
+            "set",
+            1,
+            (thisValue, args) => {
+                const target = self(thisValue, "set");
+                const offset = optNumber("set", args[1], "offset") ?? 0;
+                return Effect.map(collectBytes(ctx, args[0], "Uint8Array.set"), (source) => {
+                    if (!Number.isInteger(offset) || offset < 0 || source.length + offset > target.bytes.length) {
+                        throw rangeError("Uint8Array.set: the source does not fit at that offset.");
+                    }
+                    target.bytes.set(source, offset);
+                    return undefined;
+                });
+            },
+        ],
+        [
+            "fill",
+            1,
+            (thisValue, args) => {
+                const target = self(thisValue, "fill");
+                target.bytes.fill(coerceToNumber(args[0]), optNumber("fill", args[1], "start"), optNumber("fill", args[2], "end"));
+                return target;
+            },
+        ],
+        [
+            "reverse",
+            0,
+            (thisValue) => {
+                const target = self(thisValue, "reverse");
+                target.bytes.reverse();
+                return target;
+            },
+        ],
+        [
+            "indexOf",
+            1,
+            (thisValue, args) => self(thisValue, "indexOf").bytes.indexOf(coerceToNumber(args[0]), optNumber("indexOf", args[1], "start index")),
+        ],
+        [
+            "lastIndexOf",
+            1,
+            (thisValue, args) => {
+                const target = self(thisValue, "lastIndexOf").bytes;
+                return args[1] === undefined
+                    ? target.lastIndexOf(coerceToNumber(args[0]))
+                    : target.lastIndexOf(coerceToNumber(args[0]), optNumber("lastIndexOf", args[1], "start index"));
+            },
+        ],
+        [
+            "includes",
+            1,
+            (thisValue, args) => self(thisValue, "includes").bytes.includes(coerceToNumber(args[0]), optNumber("includes", args[1], "start index")),
+        ],
+        [
+            "join",
+            1,
+            (thisValue, args) => {
+                if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
+                    throw typeError("Uint8Array.join expects zero arguments or one string separator.");
+                }
+                const joined = self(thisValue, "join").bytes.join(args.length === 0 ? "," : args[0]);
+                checkStringLength(joined.length);
+                return joined;
+            },
+        ],
+        ["toString", 0, (thisValue) => self(thisValue, "toString").bytes.join(",")],
+        ["toBase64", 0, (thisValue) => self(thisValue, "toBase64").bytes.toBase64()],
+        ["toHex", 0, (thisValue) => self(thisValue, "toHex").bytes.toHex()],
+        ["keys", 0, (thisValue) => wrapAll(Array.from(self(thisValue, "keys").bytes.keys()))],
+        ["values", 0, (thisValue) => wrapAll(Array.from(self(thisValue, "values").bytes.values()))],
+        [
+            "entries",
+            0,
+            (thisValue) => wrapAll(Array.from(self(thisValue, "entries").bytes.entries(), ([index, byte]) => wrapAll([index, byte]))),
+        ],
+    ]);
+    return uint8Array;
+};
+export const textEncoderGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.TextEncoder;
+    const encoder = new TextEncoder();
+    defineAccessor(proto, "encoding", () => "utf-8");
+    methods(builtins, proto, [
+        ["encode", 0, (_, args) => new Bytes(builtins.Uint8Array, encoder.encode(coerceToString(args[0] ?? "")))],
+    ]);
+    return constructor(builtins, proto, {
+        name: "TextEncoder",
+        call: requiresNew("TextEncoder"),
+        construct: (_, newTarget) => Effect.succeed(new Obj(prototypeFrom(newTarget, proto))),
+    });
+};
+/** A `TextDecoder` holding the host decoder its label and options configured. */
+export class TextDecoderObj extends Obj {
+    decoder;
+    constructor(proto, decoder) {
+        super(proto);
+        this.decoder = decoder;
+    }
+}
+// The WHATWG labels for UTF-8, the only encoding CodeMode decodes.
+const utf8Labels = new Set(["unicode-1-1-utf-8", "unicode11utf8", "unicode20utf8", "utf-8", "utf8", "x-unicode20utf8"]);
+export const textDecoderGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.TextDecoder;
+    const self = (thisValue, name) => receiver(TextDecoderObj, thisValue, `TextDecoder.prototype.${name}`);
+    defineAccessor(proto, "encoding", (thisValue) => self(thisValue, "encoding").decoder.encoding);
+    defineAccessor(proto, "fatal", (thisValue) => self(thisValue, "fatal").decoder.fatal);
+    defineAccessor(proto, "ignoreBOM", (thisValue) => self(thisValue, "ignoreBOM").decoder.ignoreBOM);
+    methods(builtins, proto, [
+        [
+            "decode",
+            0,
+            (thisValue, args) => {
+                const decoder = self(thisValue, "decode").decoder;
+                if (args[0] === undefined)
+                    return "";
+                if (!(args[0] instanceof Bytes)) {
+                    throw typeError(`TextDecoder.decode expects a Uint8Array, received ${describeValue(args[0])}.`);
+                }
+                try {
+                    return decoder.decode(args[0].bytes);
+                }
+                catch {
+                    throw typeError(`TextDecoder.decode: the input is not valid ${decoder.encoding}.`);
+                }
+            },
+        ],
+    ]);
+    return constructor(builtins, proto, {
+        name: "TextDecoder",
+        call: requiresNew("TextDecoder"),
+        construct: (args, newTarget) => Effect.sync(() => {
+            const label = args[0] === undefined ? "utf-8" : coerceToString(args[0]).trim().toLowerCase();
+            if (!utf8Labels.has(label))
+                throw rangeError(`The "${label}" encoding is not supported; only UTF-8 is.`);
+            const options = args[1] instanceof Obj ? args[1] : undefined;
+            const flag = (name) => options !== undefined && Boolean(get(options, name));
+            return new TextDecoderObj(prototypeFrom(newTarget, proto), new TextDecoder("utf-8", { fatal: flag("fatal"), ignoreBOM: flag("ignoreBOM") }));
+        }),
+    });
+};

package/dist/stdlib/collections.d.ts

@@ -1,5 +1,5 @@
-import { type Runner } from "../interpreter/runner.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
 /** `Map.groupBy` and `Object.groupBy`: the same iteration, keyed into a Map or a data object. */
-export declare const groupBy: <R>(runner: Runner<R>, namespace: "Map" | "Object") => import("../interpreter/objects.js").NativeFunction<R>;
-export declare const mapGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
-export declare const setGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+export declare const groupBy: <R>(ctx: Interpreter<R>, namespace: "Map" | "Object") => import("../interpreter/objects.js").Native<R>;
+export declare const mapGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+export declare const setGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/collections.js

@@ -1,32 +1,32 @@
 import { Effect } from "effect";
 import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { define, defineAccessor, get, getOwn, hidden, isWrapper, ProgramArray, ProgramMap, ProgramObject, ProgramPromise, ProgramSet, } from "../interpreter/objects.js";
+import { invalidData, typeError } from "../interpreter/model.js";
+import { define, defineAccessor, get, getOwn, hidden, isWrapper, Arr, MapObj, Obj, PromiseObj, SetObj, } from "../interpreter/objects.js";
 import { describeValue, isRuntimeReference } from "../interpreter/references.js";
-import { applyCollectionCallback, isSupportedCallback, preserveConsumerError, toPrimitiveNumber, toPrimitiveString, } from "../interpreter/runner.js";
-const coerceGroupByPropertyKey = (runner, value, node) => {
-    if (value instanceof ProgramPromise)
+import { applyCollectionCallback, isSupportedCallback, preserveConsumerError, toPrimitiveNumber, toPrimitiveString, } from "../interpreter/callback.js";
+const coerceGroupByPropertyKey = (ctx, value) => {
+    if (value instanceof PromiseObj)
         return Effect.succeed("[object Promise]");
     if (!isWrapper(value) && isRuntimeReference(value)) {
-        throw new InterpreterRuntimeError(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`, node, "InvalidDataValue");
+        throw invalidData(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`);
     }
-    return toPrimitiveString(runner, value, node);
+    return toPrimitiveString(ctx, value);
 };
 /** `Map.groupBy` and `Object.groupBy`: the same iteration, keyed into a Map or a data object. */
-export const groupBy = (runner, namespace) => fn(runner.prototypes, "groupBy", 2, (_, args, node) => {
-    const protos = runner.prototypes;
+export const groupBy = (ctx, namespace) => fn(ctx.builtins, "groupBy", 2, (_, args) => {
+    const builtins = ctx.builtins;
     const source = args[0];
     if (source === null || source === undefined) {
-        throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node);
+        throw typeError(`${namespace}.groupBy expects an iterable collection.`);
     }
-    const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`, node);
+    const apply = applyCollectionCallback(ctx, args[1], `${namespace}.groupBy`);
     return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(source, node);
+        const cursor = yield* ctx.iterate(source);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node);
+            throw typeError(`${namespace}.groupBy expects an iterable collection.`);
         }
         if (namespace === "Map") {
-            const result = new ProgramMap(protos.Map);
+            const result = new MapObj(builtins.Map);
             let index = 0;
             while (true) {
                 const step = yield* cursor.next;
@@ -36,60 +36,60 @@ export const groupBy = (runner, namespace) => fn(runner.prototypes, "groupBy", 2
                 const key = yield* preserveConsumerError(cursor, apply([item, index]));
                 const group = result.map.get(key);
                 if (group === undefined)
-                    result.map.set(key, new ProgramArray(protos.Array, [item]));
+                    result.map.set(key, new Arr(builtins.Array, [item]));
                 else
                     group.items.push(item);
                 index += 1;
             }
         }
         // Object.groupBy returns a null-prototype object, so group names never collide with inherited methods.
-        const result = new ProgramObject(null);
+        const result = new Obj(null);
         let index = 0;
         while (true) {
             const step = yield* cursor.next;
             if (step.done)
                 return result;
             const item = step.value;
-            const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
+            const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(ctx, value)));
             const group = getOwn(result, key);
             if (group === undefined)
-                define(result, key, new ProgramArray(protos.Array, [item]));
+                define(result, key, new Arr(builtins.Array, [item]));
             else
                 group.items.push(item);
             index += 1;
         }
     });
 });
-const constructMap = (runner, init, proto, node) => {
-    const target = new ProgramMap(proto);
+const constructMap = (ctx, init, proto) => {
+    const target = new MapObj(proto);
     if (init === undefined || init === null)
         return Effect.succeed(target);
     return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(init, node);
+        const cursor = yield* ctx.iterate(init);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node);
+            throw typeError("new Map(...) expects an iterable of [key, value] pairs or no argument.");
         }
         while (true) {
             const step = yield* cursor.next;
             if (step.done)
                 return target;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
-                if (!(step.value instanceof ProgramObject)) {
-                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node);
+                if (!(step.value instanceof Obj)) {
+                    throw typeError("new Map(...) expects [key, value] pairs as entry objects.");
                 }
                 target.map.set(getOwn(step.value, 0), getOwn(step.value, 1));
             }));
         }
     });
 };
-const constructSet = (runner, init, proto, node) => {
-    const target = new ProgramSet(proto);
+const constructSet = (ctx, init, proto) => {
+    const target = new SetObj(proto);
     if (init === undefined || init === null)
         return Effect.succeed(target);
     return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(init, node);
+        const cursor = yield* ctx.iterate(init);
         if (cursor === undefined) {
-            throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node);
+            throw typeError("new Set(...) expects a synchronous iterable or no argument.");
         }
         while (true) {
             const step = yield* cursor.next;
@@ -99,52 +99,52 @@ const constructSet = (runner, init, proto, node) => {
         }
     });
 };
-export const mapGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.Map;
-    const map = constructor(protos, proto, {
+export const mapGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.Map;
+    const map = constructor(builtins, proto, {
         name: "Map",
         call: requiresNew("Map"),
-        construct: (args, newTarget, node) => constructMap(runner, args[0], prototypeFrom(newTarget, proto), node),
+        construct: (args, newTarget) => constructMap(ctx, args[0], prototypeFrom(newTarget, proto)),
     });
-    define(map, "groupBy", groupBy(runner, "Map"), hidden);
-    const self = (thisValue, name, node) => receiver(ProgramMap, thisValue, `Map.prototype.${name}`, node);
-    const wrap = (items) => new ProgramArray(protos.Array, items);
-    defineAccessor(proto, "size", (thisValue) => receiver(ProgramMap, thisValue, "Map.prototype.size").map.size);
-    methods(protos, proto, [
-        ["get", 1, (thisValue, args, node) => self(thisValue, "get", node).map.get(args[0])],
-        ["has", 1, (thisValue, args, node) => self(thisValue, "has", node).map.has(args[0])],
+    define(map, "groupBy", groupBy(ctx, "Map"), hidden);
+    const self = (thisValue, name) => receiver(MapObj, thisValue, `Map.prototype.${name}`);
+    const wrap = (items) => new Arr(builtins.Array, items);
+    defineAccessor(proto, "size", (thisValue) => receiver(MapObj, thisValue, "Map.prototype.size").map.size);
+    methods(builtins, proto, [
+        ["get", 1, (thisValue, args) => self(thisValue, "get").map.get(args[0])],
+        ["has", 1, (thisValue, args) => self(thisValue, "has").map.has(args[0])],
         [
             "set",
             2,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "set", node);
+            (thisValue, args) => {
+                const target = self(thisValue, "set");
                 target.map.set(args[0], args[1]);
                 return target;
             },
         ],
-        ["delete", 1, (thisValue, args, node) => self(thisValue, "delete", node).map.delete(args[0])],
+        ["delete", 1, (thisValue, args) => self(thisValue, "delete").map.delete(args[0])],
         [
             "clear",
             0,
-            (thisValue, _, node) => {
-                self(thisValue, "clear", node).map.clear();
+            (thisValue) => {
+                self(thisValue, "clear").map.clear();
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "keys", node).map.keys()))],
-        ["values", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "values", node).map.values()))],
+        ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").map.keys()))],
+        ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").map.values()))],
         [
             "entries",
             0,
-            (thisValue, _, node) => wrap(Array.from(self(thisValue, "entries", node).map.entries(), ([key, item]) => wrap([key, item]))),
+            (thisValue) => wrap(Array.from(self(thisValue, "entries").map.entries(), ([key, item]) => wrap([key, item]))),
         ],
         [
             "forEach",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "forEach", node);
-                const apply = applyCollectionCallback(runner, args[0], "Map.forEach", node);
+            (thisValue, args) => {
+                const target = self(thisValue, "forEach");
+                const apply = applyCollectionCallback(ctx, args[0], "Map.forEach");
                 return Effect.gen(function* () {
                     for (const [key, item] of Array.from(target.map.entries()))
                         yield* apply([item, key, target]);
@@ -155,49 +155,49 @@ export const mapGlobal = (runner) => {
     ]);
     return map;
 };
-const loadSetRecord = (runner, source, name, node) => {
-    if (source instanceof ProgramSet) {
+const loadSetRecord = (ctx, source, name) => {
+    if (source instanceof SetObj) {
         return Effect.succeed({
             size: source.set.size,
             has: (item) => Effect.succeed(source.set.has(item)),
             keys: () => Effect.succeed(source.set.values()),
         });
     }
-    if (source instanceof ProgramMap) {
+    if (source instanceof MapObj) {
         return Effect.succeed({
             size: source.map.size,
             has: (item) => Effect.succeed(source.map.has(item)),
             keys: () => Effect.succeed(source.map.keys()),
         });
     }
-    if (!(source instanceof ProgramObject)) {
-        throw new InterpreterRuntimeError(`Set.${name} expects a Set-like object.`, node);
+    if (!(source instanceof Obj)) {
+        throw typeError(`Set.${name} expects a Set-like object.`);
     }
     return Effect.gen(function* () {
-        const size = yield* toPrimitiveNumber(runner, get(source, "size"), node);
+        const size = yield* toPrimitiveNumber(ctx, get(source, "size"));
         if (Number.isNaN(size)) {
-            throw new InterpreterRuntimeError(`Set.${name} received a Set-like object with an invalid size.`, node);
+            throw typeError(`Set.${name} received a Set-like object with an invalid size.`);
         }
         const has = get(source, "has");
         const keys = get(source, "keys");
         if (!isSupportedCallback(has) || !isSupportedCallback(keys)) {
-            throw new InterpreterRuntimeError(`Set.${name} expects callable 'has' and 'keys' methods.`, node);
+            throw typeError(`Set.${name} expects callable 'has' and 'keys' methods.`);
         }
         return {
             size: Math.max(Math.trunc(size), 0),
-            has: (item) => Effect.map(runner.invokeCallable(has, source, [item], node), Boolean),
-            keys: () => Effect.flatMap(runner.invokeCallable(keys, source, [], node), (result) => {
-                if (result instanceof ProgramArray)
+            has: (item) => Effect.map(ctx.call(has, source, [item]), Boolean),
+            keys: () => Effect.flatMap(ctx.call(keys, source, []), (result) => {
+                if (result instanceof Arr)
                     return Effect.succeed(result.items);
-                throw new InterpreterRuntimeError(`Set.${name} expected 'keys' to return an iterator.`, node);
+                throw typeError(`Set.${name} expected 'keys' to return an iterator.`);
             }),
         };
     });
 };
-const setOperation = (runner, target, name, source, node) => Effect.gen(function* () {
-    const other = yield* loadSetRecord(runner, source, name, node);
+const setOperation = (ctx, target, name, source) => Effect.gen(function* () {
+    const other = yield* loadSetRecord(ctx, source, name);
     const copy = () => {
-        const result = new ProgramSet(runner.prototypes.Set);
+        const result = new SetObj(ctx.builtins.Set);
         for (const item of target.set.values())
             result.set.add(item);
         return result;
@@ -209,7 +209,7 @@ const setOperation = (runner, target, name, source, node) => Effect.gen(function
         return result;
     }
     if (name === "intersection") {
-        const result = new ProgramSet(runner.prototypes.Set);
+        const result = new SetObj(ctx.builtins.Set);
         if (target.set.size <= other.size) {
             for (const item of target.set.values()) {
                 if (yield* other.has(item))
@@ -277,55 +277,55 @@ const setOperation = (runner, target, name, source, node) => Effect.gen(function
     }
     return true;
 });
-export const setGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.Set;
-    const set = constructor(protos, proto, {
+export const setGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.Set;
+    const set = constructor(builtins, proto, {
         name: "Set",
         call: requiresNew("Set"),
-        construct: (args, newTarget, node) => constructSet(runner, args[0], prototypeFrom(newTarget, proto), node),
+        construct: (args, newTarget) => constructSet(ctx, args[0], prototypeFrom(newTarget, proto)),
     });
-    const self = (thisValue, name, node) => receiver(ProgramSet, thisValue, `Set.prototype.${name}`, node);
-    const wrap = (items) => new ProgramArray(protos.Array, items);
+    const self = (thisValue, name) => receiver(SetObj, thisValue, `Set.prototype.${name}`);
+    const wrap = (items) => new Arr(builtins.Array, items);
     const operation = (name) => [
         name,
         1,
-        (thisValue, args, node) => setOperation(runner, self(thisValue, name, node), name, args[0], node),
+        (thisValue, args) => setOperation(ctx, self(thisValue, name), name, args[0]),
     ];
-    defineAccessor(proto, "size", (thisValue) => receiver(ProgramSet, thisValue, "Set.prototype.size").set.size);
-    methods(protos, proto, [
-        ["has", 1, (thisValue, args, node) => self(thisValue, "has", node).set.has(args[0])],
+    defineAccessor(proto, "size", (thisValue) => receiver(SetObj, thisValue, "Set.prototype.size").set.size);
+    methods(builtins, proto, [
+        ["has", 1, (thisValue, args) => self(thisValue, "has").set.has(args[0])],
         [
             "add",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "add", node);
+            (thisValue, args) => {
+                const target = self(thisValue, "add");
                 target.set.add(args[0]);
                 return target;
             },
         ],
-        ["delete", 1, (thisValue, args, node) => self(thisValue, "delete", node).set.delete(args[0])],
+        ["delete", 1, (thisValue, args) => self(thisValue, "delete").set.delete(args[0])],
         [
             "clear",
             0,
-            (thisValue, _, node) => {
-                self(thisValue, "clear", node).set.clear();
+            (thisValue) => {
+                self(thisValue, "clear").set.clear();
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "keys", node).set.values()))],
-        ["values", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "values", node).set.values()))],
+        ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").set.values()))],
+        ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").set.values()))],
         [
             "entries",
             0,
-            (thisValue, _, node) => wrap(Array.from(self(thisValue, "entries", node).set.values(), (item) => wrap([item, item]))),
+            (thisValue) => wrap(Array.from(self(thisValue, "entries").set.values(), (item) => wrap([item, item]))),
         ],
         [
             "forEach",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "forEach", node);
-                const apply = applyCollectionCallback(runner, args[0], "Set.forEach", node);
+            (thisValue, args) => {
+                const target = self(thisValue, "forEach");
+                const apply = applyCollectionCallback(ctx, args[0], "Set.forEach");
                 return Effect.gen(function* () {
                     for (const item of Array.from(target.set.values()))
                         yield* apply([item, item, target]);

package/dist/stdlib/console.d.ts

@@ -1,4 +1,6 @@
-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";
 /** Captured console: every method appends one formatted line to `logs`. */
-export declare const consoleGlobal: <R>(runner: Runner<R>, logs: Array<string>) => ProgramObject;
+export declare const consoleGlobal: <R>(ctx: Interpreter<R>) => Obj;
+/** One value as `console.log` shows it. */
+export declare const formatValue: (value: unknown) => string;