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

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 { invalidData, typeError } from "../interpreter/model.js";
-import { define, defineAccessor, get, getOwn, hidden, isWrapper, ProgramArray, ProgramMap, ProgramObject, ProgramPromise, ProgramSet, } from "../interpreter/objects.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) => {
-    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 invalidData(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`);
     }
-    return toPrimitiveString(runner, value);
+    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) => {
-    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 typeError(`${namespace}.groupBy expects an iterable collection.`);
     }
-    const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`);
+    const apply = applyCollectionCallback(ctx, args[1], `${namespace}.groupBy`);
     return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(source);
+        const cursor = yield* ctx.iterate(source);
         if (cursor === undefined) {
             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,36 +36,36 @@ 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)));
+            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) => {
-    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);
+        const cursor = yield* ctx.iterate(init);
         if (cursor === undefined) {
             throw typeError("new Map(...) expects an iterable of [key, value] pairs or no argument.");
         }
@@ -74,7 +74,7 @@ const constructMap = (runner, init, proto) => {
             if (step.done)
                 return target;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
-                if (!(step.value instanceof ProgramObject)) {
+                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));
@@ -82,12 +82,12 @@ const constructMap = (runner, init, proto) => {
         }
     });
 };
-const constructSet = (runner, init, proto) => {
-    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);
+        const cursor = yield* ctx.iterate(init);
         if (cursor === undefined) {
             throw typeError("new Set(...) expects a synchronous iterable or no argument.");
         }
@@ -99,19 +99,19 @@ const constructSet = (runner, init, proto) => {
         }
     });
 };
-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) => constructMap(runner, args[0], prototypeFrom(newTarget, proto)),
+        construct: (args, newTarget) => constructMap(ctx, args[0], prototypeFrom(newTarget, proto)),
     });
-    define(map, "groupBy", groupBy(runner, "Map"), hidden);
-    const self = (thisValue, name) => receiver(ProgramMap, thisValue, `Map.prototype.${name}`);
-    const wrap = (items) => new ProgramArray(protos.Array, items);
-    defineAccessor(proto, "size", (thisValue) => receiver(ProgramMap, thisValue, "Map.prototype.size").map.size);
-    methods(protos, proto, [
+    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])],
         [
@@ -144,7 +144,7 @@ export const mapGlobal = (runner) => {
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "forEach");
-                const apply = applyCollectionCallback(runner, args[0], "Map.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,26 +155,26 @@ export const mapGlobal = (runner) => {
     ]);
     return map;
 };
-const loadSetRecord = (runner, source, name) => {
-    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)) {
+    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"));
+        const size = yield* toPrimitiveNumber(ctx, get(source, "size"));
         if (Number.isNaN(size)) {
             throw typeError(`Set.${name} received a Set-like object with an invalid size.`);
         }
@@ -185,19 +185,19 @@ const loadSetRecord = (runner, source, name) => {
         }
         return {
             size: Math.max(Math.trunc(size), 0),
-            has: (item) => Effect.map(runner.invokeCallable(has, source, [item]), Boolean),
-            keys: () => Effect.flatMap(runner.invokeCallable(keys, source, []), (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 typeError(`Set.${name} expected 'keys' to return an iterator.`);
             }),
         };
     });
 };
-const setOperation = (runner, target, name, source) => Effect.gen(function* () {
-    const other = yield* loadSetRecord(runner, source, name);
+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) => 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,23 +277,23 @@ const setOperation = (runner, target, name, source) => 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) => constructSet(runner, args[0], prototypeFrom(newTarget, proto)),
+        construct: (args, newTarget) => constructSet(ctx, args[0], prototypeFrom(newTarget, proto)),
     });
-    const self = (thisValue, name) => receiver(ProgramSet, thisValue, `Set.prototype.${name}`);
-    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) => setOperation(runner, self(thisValue, name), name, args[0]),
+        (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, [
+    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",
@@ -325,7 +325,7 @@ export const setGlobal = (runner) => {
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "forEach");
-                const apply = applyCollectionCallback(runner, args[0], "Set.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,4 @@
-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;

package/dist/stdlib/console.js

@@ -1,29 +1,29 @@
 import { toData, toProgram } from "../data.js";
 import { methods } from "../interpreter/native.js";
-import { entries, get, ProgramArray, ProgramDate, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "../interpreter/objects.js";
+import { entries, get, Arr, Bytes, DateObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "../interpreter/objects.js";
 import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
 import { coerceToString } from "./value.js";
 const consoleMethods = ["log", "info", "debug", "warn", "error", "dir", "table"];
 /** Captured console: every method appends one formatted line to `logs`. */
-export const consoleGlobal = (runner, logs) => {
-    const protos = runner.prototypes;
-    const console = new ProgramObject(protos.Object);
-    methods(protos, console, consoleMethods.map((name) => [
+export const consoleGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const console = new Obj(builtins.Object);
+    methods(builtins, console, consoleMethods.map((name) => [
         name,
         0,
         (_, args) => {
-            logs.push(formatConsoleMessage(protos, name, args));
+            ctx.logs.push(formatConsoleMessage(builtins, name, args));
             return undefined;
         },
     ]));
     return console;
 };
 const MAX_CONSOLE_DEPTH = 32;
-const formatConsoleMessage = (protos, name, args) => {
+const formatConsoleMessage = (builtins, name, args) => {
     if (name === "dir")
         return args.length === 0 ? "undefined" : formatConsoleArgument(args[0]);
     if (name === "table")
-        return formatConsoleTable(protos, args[0], args[1]);
+        return formatConsoleTable(builtins, args[0], args[1]);
     const prefix = name === "warn" ? "[warn] " : name === "error" ? "[error] " : name === "debug" ? "[debug] " : "";
     return `${prefix}${args.map((arg) => formatConsoleArgument(arg)).join(" ")}`;
 };
@@ -43,21 +43,23 @@ const formatConsoleValue = (value, seen, depth) => {
         return String(value);
     if (typeof value !== "object")
         return String(value);
-    if (value instanceof ProgramPromise)
+    if (value instanceof PromiseObj)
         return "[Promise (await it to get its value)]";
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return coerceToString(value);
-    if (value instanceof ProgramRegExp)
+    if (value instanceof RegExpObj)
         return coerceToString(value);
-    if (value instanceof ProgramURL)
+    if (value instanceof URLObj)
         return coerceToString(value);
-    if (value instanceof ProgramURLSearchParams)
+    if (value instanceof URLSearchParamsObj)
         return coerceToString(value);
+    if (value instanceof Bytes)
+        return `Uint8Array(${value.bytes.length}) [${value.bytes.join(",")}]`;
     if (depth > MAX_CONSOLE_DEPTH)
         return "...";
     if (seen.has(value))
         return "[Circular]";
-    if (value instanceof ProgramMap) {
+    if (value instanceof MapObj) {
         seen.add(value);
         try {
             const items = Array.from(value.map.entries(), ([key, item]) => `[${formatItems([key, item], seen, depth + 1)}]`);
@@ -67,7 +69,7 @@ const formatConsoleValue = (value, seen, depth) => {
             seen.delete(value);
         }
     }
-    if (value instanceof ProgramSet) {
+    if (value instanceof SetObj) {
         seen.add(value);
         try {
             return `Set(${value.set.size}) [${formatItems([...value.set.values()], seen, depth + 1)}]`;
@@ -80,9 +82,9 @@ const formatConsoleValue = (value, seen, depth) => {
         return "[opaque reference]";
     seen.add(value);
     try {
-        if (value instanceof ProgramArray)
+        if (value instanceof Arr)
             return `[${formatItems(value.items, seen, depth + 1)}]`;
-        if (!(value instanceof ProgramObject))
+        if (!(value instanceof Obj))
             return "[object Object]";
         return `{${entries(value)
             .map(([key, item]) => `${JSON.stringify(key)}:${formatConsoleValue(item, seen, depth + 1)}`)
@@ -93,12 +95,12 @@ const formatConsoleValue = (value, seen, depth) => {
     }
 };
 const formatItems = (items, seen, depth) => items.map((item) => formatConsoleValue(item, seen, depth)).join(",");
-const formatConsoleTable = (protos, value, columnsArgument) => {
+const formatConsoleTable = (builtins, value, columnsArgument) => {
     if (value === undefined)
         return "undefined";
     if (containsOpaqueReference(value))
         return "[opaque reference]";
-    const data = toProgram(protos, value, "console.table argument");
+    const data = toProgram(builtins, value, "console.table argument");
     const columns = consoleTableColumns(columnsArgument);
     const rows = consoleTableRows(data, columns);
     const keys = columns ?? Array.from(new Set(rows.flatMap((row) => Object.keys(row.values))));
@@ -117,16 +119,16 @@ const consoleTableColumns = (value) => {
     return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined;
 };
 const consoleTableRows = (data, columns) => {
-    if (data instanceof ProgramArray) {
+    if (data instanceof Arr) {
         return data.items.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
     }
-    if (data instanceof ProgramObject) {
+    if (data instanceof Obj) {
         return entries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
     }
     return [{ index: "0", values: { Value: data } }];
 };
 const consoleTableValues = (value, columns) => {
-    if (value instanceof ProgramObject && !(value instanceof ProgramArray)) {
+    if (value instanceof Obj && !(value instanceof Arr)) {
         if (columns !== undefined)
             return Object.fromEntries(columns.map((column) => [column, get(value, column)]));
         return Object.fromEntries(entries(value));

package/dist/stdlib/date.d.ts

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