@opencode/codemode 2.0.3 → 2.0.5

package/dist/interpreter/references.js

@@ -1,14 +1,14 @@
 import { ToolReference } from "../tool-runtime.js";
-import { InterpreterRuntimeError } from "./model.js";
-import { Callable, getOwn, isWrapper, ownKeys, ProgramArray, ProgramDate, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./objects.js";
+import { invalidData } from "./model.js";
+import { Callable, getOwn, isWrapper, ownKeys, Arr, Bytes, DateObj, GeneratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
 /** Values that cannot cross the data boundary. */
 export const isRuntimeReference = (value) => value instanceof Callable ||
-    value instanceof ProgramGenerator ||
+    value instanceof GeneratorObj ||
     value instanceof ToolReference ||
-    value instanceof ProgramPromise ||
+    value instanceof PromiseObj ||
     isWrapper(value);
 function* childValues(value) {
-    if (!(value instanceof ProgramObject))
+    if (!(value instanceof Obj))
         return;
     for (const key of ownKeys(value))
         yield getOwn(value, key);
@@ -37,33 +37,35 @@ export const containsRuntimeReference = (value) => find(value, isRuntimeReferenc
 // Wrapper values are data here, not opaque interpreter references.
 export const containsOpaqueReference = (value) => find(value, (current) => !isWrapper(current) && isRuntimeReference(current), isWrapper, new Set());
 // Reject cycles before mutation so later boundary walks remain safe.
-export const rejectCircularInsertion = (container, value, label, node, seen = new Set()) => {
+export const rejectCircularInsertion = (container, value, label, seen = new Set()) => {
     if (find(value, (current) => current === container, isRuntimeReference, seen)) {
-        throw new InterpreterRuntimeError(`${label} contains a circular value.`, node, "InvalidDataValue");
+        throw invalidData(`${label} contains a circular value.`);
     }
 };
 export const describeValue = (value) => {
     if (value === null || value === undefined)
         return String(value);
-    if (value instanceof ProgramArray)
+    if (value instanceof Arr)
         return "an array";
-    if (value instanceof ProgramPromise)
+    if (value instanceof PromiseObj)
         return "an un-awaited Promise";
     if (value instanceof ToolReference)
         return "a tool reference";
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return "a Date";
-    if (value instanceof ProgramRegExp)
+    if (value instanceof RegExpObj)
         return "a RegExp";
-    if (value instanceof ProgramMap)
+    if (value instanceof MapObj)
         return "a Map";
-    if (value instanceof ProgramSet)
+    if (value instanceof SetObj)
         return "a Set";
-    if (value instanceof ProgramURL)
+    if (value instanceof URLObj)
         return "a URL";
-    if (value instanceof ProgramURLSearchParams)
+    if (value instanceof URLSearchParamsObj)
         return "a URLSearchParams";
-    if (value instanceof ProgramGenerator)
+    if (value instanceof Bytes)
+        return "a Uint8Array";
+    if (value instanceof GeneratorObj)
         return "a generator";
     if (isRuntimeReference(value))
         return "a function";

package/dist/interpreter/scope.js

@@ -1,4 +1,4 @@
-import { InterpreterRuntimeError, referenceError } from "./model.js";
+import { referenceError, typeError } from "./model.js";
 export class ScopeStack {
     scopes;
     constructor(scopes) {
@@ -7,14 +7,14 @@ export class ScopeStack {
     reserve(name, mutable, node) {
         const scope = this.current();
         if (scope.has(name)) {
-            throw new InterpreterRuntimeError(`Identifier '${name}' has already been declared.`, node);
+            throw typeError(`Identifier '${name}' has already been declared.`, node);
         }
         scope.set(name, { mutable, value: undefined, initialized: false });
     }
     initialize(name, value, node) {
         const binding = this.current().get(name);
         if (!binding || binding.initialized !== false) {
-            throw new InterpreterRuntimeError(`Identifier '${name}' has not been reserved for initialization.`, node);
+            throw typeError(`Identifier '${name}' has not been reserved for initialization.`, node);
         }
         binding.value = value;
         binding.initialized = true;
@@ -22,7 +22,7 @@ export class ScopeStack {
     declare(name, value, mutable, node) {
         const scope = this.current();
         if (scope.has(name)) {
-            throw new InterpreterRuntimeError(`Identifier '${name}' has already been declared.`, node);
+            throw typeError(`Identifier '${name}' has already been declared.`, node);
         }
         scope.set(name, { mutable, value, initialized: true });
     }
@@ -45,7 +45,7 @@ export class ScopeStack {
             throw referenceError(`Cannot access '${name}' before initialization.`, node);
         }
         if (!binding.mutable) {
-            throw new InterpreterRuntimeError(`Cannot assign to constant '${name}'.`, node);
+            throw typeError(`Cannot assign to constant '${name}'.`, node);
         }
         binding.value = value;
         return value;
@@ -63,7 +63,7 @@ export class ScopeStack {
     current() {
         const scope = this.scopes[this.scopes.length - 1];
         if (!scope) {
-            throw new InterpreterRuntimeError("Interpreter scope stack is empty.");
+            throw typeError("Interpreter scope stack is empty.");
         }
         return scope;
     }

package/dist/openapi/types.d.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import type { Tool, JsonSchema } from "../tool.js";
-/** A parsed OpenAPI 3.x document. YAML must be parsed by the host. */
+/** A parsed OpenAPI 3.x document. YAML must be parsed by the ctx. */
 export type Document = Record<string, unknown>;
 /** The operation identity handed to auth resolution and errors. */
 export type Operation = {

package/dist/stdlib/array.d.ts

@@ -1,5 +1,4 @@
 import { Effect } from "effect";
-import { type AstNode } from "../interpreter/model.js";
-import { type Runner } from "../interpreter/runner.js";
-export declare const sortArray: <R>(runner: Runner<R>, target: Array<unknown>, comparator: unknown, name: string, node: AstNode) => Effect.Effect<Array<unknown>, unknown, R>;
-export declare const arrayGlobal: <R>(runner: Runner<R>) => import("../interpreter/objects.js").NativeFunction<R>;
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const sortArray: <R>(ctx: Interpreter<R>, target: Array<unknown>, comparator: unknown, name: string) => Effect.Effect<Array<unknown>, unknown, R>;
+export declare const arrayGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/array.js

@@ -1,56 +1,55 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
-import { InterpreterRuntimeError, rangeError } from "../interpreter/model.js";
-import { get, ProgramArray, ProgramGenerator, ProgramObject } from "../interpreter/objects.js";
+import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interpreter/limits.js";
+import { invalidData, rangeError, typeError } from "../interpreter/model.js";
+import { get, Arr, GeneratorObj, Obj } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
-import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
+import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js";
 import { compareText } from "../tool-runtime.js";
 import { coerceToNumber, coerceToString } from "./value.js";
-const MAX_LENGTH = 4_294_967_295;
-const arrayLikeSource = (source, node) => {
-    if (source instanceof ProgramObject && typeof get(source, "length") === "number") {
+const arrayLikeSource = (source) => {
+    if (source instanceof Obj && typeof get(source, "length") === "number") {
         const length = get(source, "length");
         const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length);
-        if (normalized > MAX_LENGTH)
-            throw new RangeError("Invalid array length");
+        checkArrayLength(normalized);
         return { length: normalized, source };
     }
-    throw new InterpreterRuntimeError(`Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`, node, "InvalidDataValue");
+    throw invalidData(`Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`);
 };
-const arrayFrom = (runner, args, node) => {
+const arrayFrom = (ctx, args) => {
     const source = args[0];
-    const proto = runner.prototypes.Array;
-    const apply = args.length < 2 || args[1] === undefined ? undefined : applyCollectionCallback(runner, args[1], "Array.from", node);
+    const proto = ctx.builtins.Array;
+    const apply = args.length < 2 || args[1] === undefined ? undefined : applyCollectionCallback(ctx, args[1], "Array.from");
     return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(source, node);
+        const cursor = yield* ctx.iterate(source);
         if (cursor === undefined) {
-            if (source instanceof ProgramGenerator) {
-                throw new InterpreterRuntimeError("Array.from expects a synchronous iterable or array-like value.", node);
+            if (source instanceof GeneratorObj) {
+                throw typeError("Array.from expects a synchronous iterable or array-like value.");
             }
-            const arrayLike = arrayLikeSource(source, node);
+            const arrayLike = arrayLikeSource(source);
             const values = [];
             for (let index = 0; index < arrayLike.length; index += 1) {
                 const item = get(arrayLike.source, index);
                 values.push(apply === undefined ? item : yield* apply([item, index]));
             }
-            return new ProgramArray(proto, values);
+            return new Arr(proto, values);
         }
         const values = [];
         let index = 0;
         while (true) {
             const step = yield* cursor.next;
             if (step.done)
-                return new ProgramArray(proto, values);
+                return new Arr(proto, values);
             values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])));
             index += 1;
         }
     });
 };
-export const sortArray = (runner, target, comparator, name, node) => {
+export const sortArray = (ctx, target, comparator, name) => {
     if (comparator === undefined) {
         return Effect.sync(() => [...target].sort((a, b) => compareText(coerceToString(a), coerceToString(b))));
     }
-    const apply = applyCollectionCallback(runner, comparator, name, node);
+    const apply = applyCollectionCallback(ctx, comparator, name);
     const mergeSort = (items) => {
         if (items.length <= 1)
             return Effect.succeed(items);
@@ -77,38 +76,38 @@ export const sortArray = (runner, target, comparator, name, node) => {
     return Effect.map(mergeSort(defined), (items) => [...items, ...Array(undefinedCount).fill(undefined)]);
 };
 // Array constructs identically with or without new, like JS.
-export const arrayGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.Array;
-    const wrap = (items) => new ProgramArray(proto, items);
-    const construct = (args, into, node) => {
+export const arrayGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.Array;
+    const wrap = (items) => new Arr(proto, items);
+    const construct = (args, into) => {
         if (args.length !== 1)
-            return new ProgramArray(into, [...args]);
+            return new Arr(into, [...args]);
         const first = args[0];
         if (typeof first !== "number")
-            return new ProgramArray(into, [first]);
-        if (!Number.isInteger(first) || first < 0 || first > MAX_LENGTH)
-            throw rangeError("Invalid array length.", node);
+            return new Arr(into, [first]);
+        if (!Number.isInteger(first) || first < 0 || first > MAX_ARRAY_LENGTH)
+            throw rangeError("Invalid array length.");
         // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
-        return new ProgramArray(into, new Array(first));
+        return new Arr(into, new Array(first));
     };
-    const array = constructor(protos, proto, {
+    const array = constructor(builtins, proto, {
         name: "Array",
         length: 1,
-        call: (_, args, node) => Effect.sync(() => construct(args, proto, node)),
-        construct: (args, newTarget, node) => Effect.sync(() => construct(args, prototypeFrom(newTarget, proto), node)),
+        call: (_, args) => Effect.sync(() => construct(args, proto)),
+        construct: (args, newTarget) => Effect.sync(() => construct(args, prototypeFrom(newTarget, proto))),
     });
-    methods(protos, array, [
-        ["isArray", 1, (_, args) => args[0] instanceof ProgramArray],
+    methods(builtins, array, [
+        ["isArray", 1, (_, args) => args[0] instanceof Arr],
         ["of", 0, (_, args) => wrap([...args])],
-        ["from", 1, (_, args, node) => arrayFrom(runner, args, node)],
+        ["from", 1, (_, args) => arrayFrom(ctx, args)],
     ]);
-    const self = (thisValue, name, node) => receiver(ProgramArray, thisValue, `Array.prototype.${name}`, node);
-    const optNumber = (name, value, label, node) => {
+    const self = (thisValue, name) => receiver(Arr, thisValue, `Array.prototype.${name}`);
+    const optNumber = (name, value, label) => {
         if (value === undefined)
             return undefined;
         if (typeof value !== "number") {
-            throw new InterpreterRuntimeError(`Array.${name} expects ${label} to be a number.`, node);
+            throw typeError(`Array.${name} expects ${label} to be a number.`);
         }
         return value;
     };
@@ -116,84 +115,90 @@ export const arrayGlobal = (runner) => {
     const iterate = (name, length, body) => [
         name,
         length,
-        (thisValue, args, node) => {
-            const target = self(thisValue, name, node);
-            return body(target.items, target, applyCollectionCallback(runner, args[0], `Array.${name}`, node), args, node);
+        (thisValue, args) => {
+            const target = self(thisValue, name);
+            return body(target.items, target, applyCollectionCallback(ctx, args[0], `Array.${name}`), args);
         },
     ];
-    methods(protos, proto, [
+    methods(builtins, proto, [
         [
             "join",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "join", node).items;
+            (thisValue, args) => {
+                const target = self(thisValue, "join").items;
                 if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
-                    throw new InterpreterRuntimeError("Array.join expects zero arguments or one string separator.", node);
+                    throw typeError("Array.join expects zero arguments or one string separator.");
                 }
-                return target.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : args[0]);
+                const joined = target
+                    .map((item) => coerceToString(item ?? ""))
+                    .join(args.length === 0 ? "," : args[0]);
+                checkStringLength(joined.length);
+                return joined;
             },
         ],
         [
             "toString",
             0,
-            (thisValue, _, node) => self(thisValue, "toString", node)
+            (thisValue) => self(thisValue, "toString")
                 .items.map((item) => coerceToString(item ?? ""))
                 .join(","),
         ],
         [
             "includes",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "includes", node).items;
+            (thisValue, args) => {
+                const target = self(thisValue, "includes").items;
                 if (args.length === 0 || args.length > 2) {
-                    throw new InterpreterRuntimeError("Array.includes expects a value and optional start index.", node);
+                    throw typeError("Array.includes expects a value and optional start index.");
                 }
-                return target.includes(args[0], optNumber("includes", args[1], "start index", node));
+                return target.includes(args[0], optNumber("includes", args[1], "start index"));
             },
         ],
         [
             "indexOf",
             1,
-            (thisValue, args, node) => self(thisValue, "indexOf", node).items.indexOf(args[0], optNumber("indexOf", args[1], "start index", node)),
+            (thisValue, args) => self(thisValue, "indexOf").items.indexOf(args[0], optNumber("indexOf", args[1], "start index")),
         ],
         [
             "lastIndexOf",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "lastIndexOf", node).items;
+            (thisValue, args) => {
+                const target = self(thisValue, "lastIndexOf").items;
                 return args[1] === undefined
                     ? target.lastIndexOf(args[0])
-                    : target.lastIndexOf(args[0], optNumber("lastIndexOf", args[1], "start index", node));
+                    : target.lastIndexOf(args[0], optNumber("lastIndexOf", args[1], "start index"));
             },
         ],
-        [
-            "at",
-            1,
-            (thisValue, args, node) => self(thisValue, "at", node).items.at(optNumber("at", args[0], "index", node) ?? 0),
-        ],
+        ["at", 1, (thisValue, args) => self(thisValue, "at").items.at(optNumber("at", args[0], "index") ?? 0)],
         [
             "slice",
             2,
-            (thisValue, args, node) => wrap(self(thisValue, "slice", node).items.slice(optNumber("slice", args[0], "start", node), optNumber("slice", args[1], "end", node))),
+            (thisValue, args) => wrap(self(thisValue, "slice").items.slice(optNumber("slice", args[0], "start"), optNumber("slice", args[1], "end"))),
         ],
         [
             "concat",
             1,
-            (thisValue, args, node) => wrap(self(thisValue, "concat", node).items.concat(...args.map((item) => (item instanceof ProgramArray ? item.items : item)))),
+            (thisValue, args) => {
+                const joined = self(thisValue, "concat").items.concat(...args.map((item) => (item instanceof Arr ? item.items : item)));
+                checkArrayLength(joined.length);
+                return wrap(joined);
+            },
         ],
         [
             "flat",
             0,
-            (thisValue, args, node) => {
-                const flatten = (items, depth) => items.flatMap((item) => (item instanceof ProgramArray && depth > 0 ? flatten(item.items, depth - 1) : [item]));
-                return wrap(flatten(self(thisValue, "flat", node).items, optNumber("flat", args[0], "depth", node) ?? 1));
+            (thisValue, args) => {
+                const flatten = (items, depth) => items.flatMap((item) => (item instanceof Arr && depth > 0 ? flatten(item.items, depth - 1) : [item]));
+                const flattened = flatten(self(thisValue, "flat").items, optNumber("flat", args[0], "depth") ?? 1);
+                checkArrayLength(flattened.length);
+                return wrap(flattened);
             },
         ],
         [
             "reverse",
             0,
-            (thisValue, _, node) => {
-                const target = self(thisValue, "reverse", node);
+            (thisValue) => {
+                const target = self(thisValue, "reverse");
                 target.items.reverse();
                 return target;
             },
@@ -201,18 +206,18 @@ export const arrayGlobal = (runner) => {
         [
             "sort",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "sort", node);
+            (thisValue, args) => {
+                const target = self(thisValue, "sort");
                 const items = target.items;
                 const length = items.length;
                 const holeCount = Array.from({ length }, (_, index) => Object.hasOwn(items, index)).filter((o) => !o).length;
                 const itemCount = length - holeCount;
-                return Effect.map(sortArray(runner, items, args[0], "Array.sort", node), (sorted) => {
+                return Effect.map(sortArray(ctx, items, args[0], "Array.sort"), (sorted) => {
                     sorted.slice(0, itemCount).forEach((item, index) => {
                         items[index] = item;
                     });
                     Array.from({ length: holeCount }, (_, index) => itemCount + index).forEach((index) => {
-                        Reflect.deleteProperty(items, index);
+                        delete items[index];
                     });
                     return target;
                 });
@@ -221,18 +226,18 @@ export const arrayGlobal = (runner) => {
         [
             "toSorted",
             1,
-            (thisValue, args, node) => Effect.map(sortArray(runner, self(thisValue, "toSorted", node).items, args[0], "Array.toSorted", node), wrap),
+            (thisValue, args) => Effect.map(sortArray(ctx, self(thisValue, "toSorted").items, args[0], "Array.toSorted"), wrap),
         ],
-        ["toReversed", 0, (thisValue, _, node) => wrap([...self(thisValue, "toReversed", node).items].reverse())],
+        ["toReversed", 0, (thisValue) => wrap([...self(thisValue, "toReversed").items].reverse())],
         [
             "with",
             2,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "with", node).items;
-                const index = optNumber("with", args[0], "index", node) ?? 0;
+            (thisValue, args) => {
+                const target = self(thisValue, "with").items;
+                const index = optNumber("with", args[0], "index") ?? 0;
                 const resolved = index < 0 ? target.length + index : index;
                 if (resolved < 0 || resolved >= target.length)
-                    throw rangeError("Array.with index is out of range.", node);
+                    throw rangeError("Array.with index is out of range.");
                 const copied = [...target];
                 copied[resolved] = args[1];
                 return wrap(copied);
@@ -241,83 +246,83 @@ export const arrayGlobal = (runner) => {
         [
             "push",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "push", node);
+            (thisValue, args) => {
+                const target = self(thisValue, "push");
                 // Validate all insertions before mutating to avoid partial cyclic updates.
                 for (const item of args)
-                    rejectCircularInsertion(target, item, "Array.push result", node);
+                    rejectCircularInsertion(target, item, "Array.push result");
                 return target.items.push(...args);
             },
         ],
         [
             "unshift",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "unshift", node);
+            (thisValue, args) => {
+                const target = self(thisValue, "unshift");
                 for (const item of args)
-                    rejectCircularInsertion(target, item, "Array.unshift result", node);
+                    rejectCircularInsertion(target, item, "Array.unshift result");
                 return target.items.unshift(...args);
             },
         ],
-        ["pop", 0, (thisValue, _, node) => self(thisValue, "pop", node).items.pop()],
-        ["shift", 0, (thisValue, _, node) => self(thisValue, "shift", node).items.shift()],
+        ["pop", 0, (thisValue) => self(thisValue, "pop").items.pop()],
+        ["shift", 0, (thisValue) => self(thisValue, "shift").items.shift()],
         [
             "splice",
             2,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "splice", node);
+            (thisValue, args) => {
+                const target = self(thisValue, "splice");
                 if (args.length === 0)
                     return wrap(target.items.splice(0, 0));
-                const start = optNumber("splice", args[0], "start", node) ?? 0;
+                const start = optNumber("splice", args[0], "start") ?? 0;
                 if (args.length === 1)
                     return wrap(target.items.splice(start));
-                const deleteCount = optNumber("splice", args[1], "delete count", node) ?? 0;
+                const deleteCount = optNumber("splice", args[1], "delete count") ?? 0;
                 const inserted = args.slice(2);
                 for (const item of inserted)
-                    rejectCircularInsertion(target, item, "Array.splice result", node);
+                    rejectCircularInsertion(target, item, "Array.splice result");
                 return wrap(target.items.splice(start, deleteCount, ...inserted));
             },
         ],
         [
             "toSpliced",
             2,
-            (thisValue, args, node) => {
-                const copied = [...self(thisValue, "toSpliced", node).items];
+            (thisValue, args) => {
+                const copied = [...self(thisValue, "toSpliced").items];
                 if (args.length === 0)
                     return wrap(copied);
-                const start = optNumber("toSpliced", args[0], "start", node) ?? 0;
+                const start = optNumber("toSpliced", args[0], "start") ?? 0;
                 if (args.length === 1)
                     copied.splice(start);
                 else
-                    copied.splice(start, optNumber("toSpliced", args[1], "delete count", node) ?? 0, ...args.slice(2));
+                    copied.splice(start, optNumber("toSpliced", args[1], "delete count") ?? 0, ...args.slice(2));
                 return wrap(copied);
             },
         ],
         [
             "fill",
             1,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "fill", node);
-                rejectCircularInsertion(target, args[0], "Array.fill result", node);
-                target.items.fill(args[0], optNumber("fill", args[1], "start", node), optNumber("fill", args[2], "end", node));
+            (thisValue, args) => {
+                const target = self(thisValue, "fill");
+                rejectCircularInsertion(target, args[0], "Array.fill result");
+                target.items.fill(args[0], optNumber("fill", args[1], "start"), optNumber("fill", args[2], "end"));
                 return target;
             },
         ],
         [
             "copyWithin",
             2,
-            (thisValue, args, node) => {
-                const target = self(thisValue, "copyWithin", node);
-                target.items.copyWithin(optNumber("copyWithin", args[0], "target index", node) ?? 0, optNumber("copyWithin", args[1], "start", node) ?? 0, optNumber("copyWithin", args[2], "end", node));
+            (thisValue, args) => {
+                const target = self(thisValue, "copyWithin");
+                target.items.copyWithin(optNumber("copyWithin", args[0], "target index") ?? 0, optNumber("copyWithin", args[1], "start") ?? 0, optNumber("copyWithin", args[2], "end"));
                 return target;
             },
         ],
-        ["keys", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "keys", node).items.keys()))],
-        ["values", 0, (thisValue, _, node) => wrap([...self(thisValue, "values", node).items])],
+        ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").items.keys()))],
+        ["values", 0, (thisValue) => wrap([...self(thisValue, "values").items])],
         [
             "entries",
             0,
-            (thisValue, _, node) => wrap(Array.from(self(thisValue, "entries", node).items.entries(), ([index, item]) => wrap([index, item]))),
+            (thisValue) => wrap(Array.from(self(thisValue, "entries").items.entries(), ([index, item]) => wrap([index, item]))),
         ],
         iterate("map", 1, (target, receiver, apply) => Effect.gen(function* () {
             const length = target.length;
@@ -337,7 +342,7 @@ export const arrayGlobal = (runner) => {
                 if (!(index in target))
                     continue;
                 const mapped = yield* apply([target[index], index, receiver]);
-                if (mapped instanceof ProgramArray)
+                if (mapped instanceof Arr)
                     values.push(...mapped.items);
                 else
                     values.push(mapped);
@@ -416,7 +421,7 @@ export const arrayGlobal = (runner) => {
             }
             return undefined;
         })),
-        iterate("reduce", 1, (target, receiver, apply, args, node) => Effect.gen(function* () {
+        iterate("reduce", 1, (target, receiver, apply, args) => Effect.gen(function* () {
             const length = target.length;
             let start = 0;
             let accumulator = args[1];
@@ -424,7 +429,7 @@ export const arrayGlobal = (runner) => {
                 while (start < length && !(start in target))
                     start += 1;
                 if (start === length) {
-                    throw new InterpreterRuntimeError("Array.reduce of an empty array with no initial value.", node);
+                    throw typeError("Array.reduce of an empty array with no initial value.");
                 }
                 accumulator = target[start];
                 start += 1;
@@ -436,14 +441,14 @@ export const arrayGlobal = (runner) => {
             }
             return accumulator;
         })),
-        iterate("reduceRight", 1, (target, receiver, apply, args, node) => Effect.gen(function* () {
+        iterate("reduceRight", 1, (target, receiver, apply, args) => Effect.gen(function* () {
             let start = target.length - 1;
             let accumulator = args[1];
             if (args.length < 2) {
                 while (start >= 0 && !(start in target))
                     start -= 1;
                 if (start < 0) {
-                    throw new InterpreterRuntimeError("Array.reduceRight of an empty array with no initial value.", node);
+                    throw typeError("Array.reduceRight of an empty array with no initial value.");
                 }
                 accumulator = target[start];
                 start -= 1;

package/dist/stdlib/bytes.d.ts

@@ -0,0 +1,10 @@
+import { Obj } from "../interpreter/objects.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const uint8ArrayGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+export declare const textEncoderGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+/** A `TextDecoder` holding the host decoder its label and options configured. */
+export declare class TextDecoderObj extends Obj {
+    readonly decoder: TextDecoder;
+    constructor(proto: Obj, decoder: TextDecoder);
+}
+export declare const textDecoderGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;