@opencode/codemode 2.0.15 → 2.0.17

package/dist/interpreter/model.js

@@ -49,7 +49,7 @@ export const referenceError = failure("ReferenceError");
 export const syntaxError = failure("SyntaxError");
 export const uriError = failure("URIError");
 // Orient the agent rather than enumerate JavaScript; interpreter-support.md is the full matrix.
-export const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, BigInt, and custom Symbols. Use plain functions and data objects instead.";
+export const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, getters/setters, BigInt, and custom Symbols. Use plain functions and data objects instead.";
 export const unsupportedSyntax = (kind, node) => new PendingThrow("SyntaxError", `Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
 // Acorn lines are 1-based and its columns are 0-based. Diagnostics use 1-based columns of the submitted source.
 export const sourceLocation = (node) => ({

package/dist/interpreter/objects.d.ts

@@ -38,6 +38,8 @@ export declare const frozen: Attributes;
 export declare class Obj {
     proto: Obj | null;
     readonly props: Map<string | symbol, Slot>;
+    /** [[Extensible]]: cleared by `Object.preventExtensions`, `seal`, and `freeze`. */
+    extensible: boolean;
     constructor(proto: Obj | null);
     /** The class name `Object.prototype.toString` reports: `[object Map]`. */
     readonly tag: string;
@@ -59,6 +61,8 @@ export declare class Obj {
 export declare class Arr extends Obj {
     readonly items: Array<Value>;
     readonly tag = "Array";
+    /** The attributes every live element shares; `seal` and `freeze` narrow them since elements have no slots. */
+    elements: Attributes;
     constructor(proto: Obj, items?: Array<Value>);
     get describe(): string;
     toString(): string;
@@ -80,6 +84,7 @@ export declare abstract class Opaque extends Obj {
     inspect(): string;
 }
 export declare abstract class Callable extends Opaque {
+    readonly length: number;
     readonly tag = "Function";
     constructor(proto: Obj, name: string, length: number);
     get describe(): string;
@@ -90,7 +95,17 @@ export declare class Fn extends Callable {
     readonly capturedScopes: Array<Map<string, Binding>>;
     readonly async: boolean;
     readonly generator: boolean;
-    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: Array<Map<string, Binding>>, async: boolean, generator: boolean);
+    /** Arrows have no `this` or `arguments` of their own; they read the enclosing function's. */
+    readonly arrow: boolean;
+    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: Array<Map<string, Binding>>, async: boolean, generator: boolean, 
+    /** Arrows have no `this` or `arguments` of their own; they read the enclosing function's. */
+    arrow: boolean);
+}
+/** The strict `arguments` object: an ordinary object with indexed own properties and a hidden `length`. */
+export declare class Arguments extends Obj {
+    readonly tag = "Arguments";
+    constructor(proto: Obj, args: Array<Value>);
+    iterator(): ArrayIterator<Value>;
 }
 export type NativeCall<R> = (thisValue: Value, args: Array<Value>) => Effect.Effect<Value, unknown, R>;
 export type NativeConstruct<R> = (args: Array<Value>, newTarget: Callable) => Effect.Effect<Value, unknown, R>;
@@ -177,6 +192,17 @@ export declare class SetObj extends Wrapper {
     toHost(item: (value: Value) => unknown): Set<unknown>;
     iterator(): SetIterator<Value>;
 }
+/** Keys are program objects, so a host WeakMap gives the same lifetime rule as JavaScript without any bookkeeping. */
+export declare class WeakMapObj extends Wrapper {
+    readonly tag = "WeakMap";
+    readonly map: WeakMap<Obj, Value>;
+    inspect(): string;
+}
+export declare class WeakSetObj extends Wrapper {
+    readonly tag = "WeakSet";
+    readonly set: WeakSet<Obj>;
+    inspect(): string;
+}
 export declare class URLSearchParamsObj extends Wrapper {
     readonly params: URLSearchParams;
     readonly tag = "URLSearchParams";
@@ -232,6 +258,8 @@ export declare const has: (target: Obj, key: PropertyKey) => boolean;
 export declare const hasPrototype: (value: Value, proto: Obj) => boolean;
 /** [[Set]]: an inherited setter or read-only property decides before an own data property is created. */
 export declare const set: (target: Obj, key: PropertyKey, value: Value) => boolean;
+/** Creating a property on a non-extensible object is the one [[Set]] failure with its own message. */
+export declare const rejectAddition: (target: Obj, key: string | symbol | number) => void;
 /** [[DefineOwnProperty]] for a data property, ignoring the chain. */
 export declare const define: (target: Obj, key: PropertyKey, value: Value, attrs?: Attributes) => void;
 export declare const defineAccessor: (target: Obj, key: PropertyKey, get: Getter | undefined, set?: Setter) => void;

package/dist/interpreter/objects.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { ToolReference } from "../tool-runtime.js";
 import { checkArrayLength } from "./limits.js";
-import { AsyncIteratorSymbol, IteratorSymbol, } from "./model.js";
+import { AsyncIteratorSymbol, IteratorSymbol, rangeError, typeError, } from "./model.js";
 /** Ordinary assignment: writable, enumerable, configurable. */
 export const data = { writable: true, enumerable: true, configurable: true };
 /** Built-in methods and `constructor`: writable and configurable but hidden from enumeration. */
@@ -17,6 +17,8 @@ export const frozen = { writable: false, enumerable: false, configurable: false
 export class Obj {
     proto;
     props = new Map();
+    /** [[Extensible]]: cleared by `Object.preventExtensions`, `seal`, and `freeze`. */
+    extensible = true;
     constructor(proto) {
         this.proto = proto;
     }
@@ -60,6 +62,8 @@ export class Obj {
 export class Arr extends Obj {
     items;
     tag = "Array";
+    /** The attributes every live element shares; `seal` and `freeze` narrow them since elements have no slots. */
+    elements = data;
     constructor(proto, items = []) {
         super(proto);
         this.items = items;
@@ -108,9 +112,11 @@ export class Opaque extends Obj {
     }
 }
 export class Callable extends Opaque {
+    length;
     tag = "Function";
     constructor(proto, name, length) {
         super(proto);
+        this.length = length;
         define(this, "length", length, readonly);
         define(this, "name", name, readonly);
     }
@@ -124,7 +130,10 @@ export class Fn extends Callable {
     capturedScopes;
     async;
     generator;
-    constructor(proto, name, parameters, body, capturedScopes, async, generator) {
+    arrow;
+    constructor(proto, name, parameters, body, capturedScopes, async, generator, 
+    /** Arrows have no `this` or `arguments` of their own; they read the enclosing function's. */
+    arrow) {
         const optional = parameters.findIndex((p) => p.type === "AssignmentPattern" || p.type === "RestElement");
         super(proto, name, optional === -1 ? parameters.length : optional);
         this.parameters = parameters;
@@ -132,6 +141,21 @@ export class Fn extends Callable {
         this.capturedScopes = capturedScopes;
         this.async = async;
         this.generator = generator;
+        this.arrow = arrow;
+    }
+}
+/** The strict `arguments` object: an ordinary object with indexed own properties and a hidden `length`. */
+export class Arguments extends Obj {
+    tag = "Arguments";
+    constructor(proto, args) {
+        super(proto);
+        args.forEach((arg, index) => define(this, String(index), arg));
+        define(this, "length", args.length, hidden);
+    }
+    iterator() {
+        return keys(this)
+            .map((key) => get(this, key))
+            .values();
     }
 }
 export class Native extends Callable {
@@ -257,6 +281,21 @@ export class SetObj extends Wrapper {
         return this.set.values();
     }
 }
+/** Keys are program objects, so a host WeakMap gives the same lifetime rule as JavaScript without any bookkeeping. */
+export class WeakMapObj extends Wrapper {
+    tag = "WeakMap";
+    map = new WeakMap();
+    inspect() {
+        return "WeakMap { <items unknown> }";
+    }
+}
+export class WeakSetObj extends Wrapper {
+    tag = "WeakSet";
+    set = new WeakSet();
+    inspect() {
+        return "WeakSet { <items unknown> }";
+    }
+}
 export class URLSearchParamsObj extends Wrapper {
     params;
     tag = "URLSearchParams";
@@ -363,10 +402,12 @@ export const own = (target, key) => {
         const at = index(target, name);
         if (at !== undefined) {
             const items = elements(target);
-            return at in items ? { value: items[at], ...data } : undefined;
+            if (!(at in items))
+                return undefined;
+            return { value: items[at], ...(target instanceof Arr ? target.elements : data) };
         }
         if (target instanceof Arr && name === "length") {
-            return { value: target.items.length, writable: true, enumerable: false, configurable: false };
+            return { value: target.items.length, writable: target.elements.writable, enumerable: false, configurable: false };
         }
     }
     return target.props.get(name);
@@ -403,16 +444,22 @@ export const hasPrototype = (value, proto) => {
 const writeElement = (target, name, value) => {
     const at = index(target, name);
     if (at !== undefined) {
-        if (target instanceof Bytes)
+        if (target instanceof Bytes) {
             target.bytes[at] = typeof value === "number" ? value : Number(value);
-        else
-            target.items[at] = value;
+            return true;
+        }
+        if (!(at in target.items))
+            rejectAddition(target, at);
+        target.items[at] = value;
         return true;
     }
     if (!(target instanceof Arr) || name !== "length")
         return undefined;
     const length = typeof value === "number" ? value : Number(value);
     if (!Number.isInteger(length) || length < 0)
+        throw rangeError("Invalid array length");
+    // Shrinking deletes elements, which a sealed array forbids.
+    if (length < target.items.length && !target.elements.configurable)
         return false;
     checkArrayLength(length);
     target.items.length = length;
@@ -448,9 +495,16 @@ export const set = (target, key, value) => {
         if (written !== undefined)
             return written;
     }
+    rejectAddition(target, name);
     target.props.set(name, { value, ...data });
     return true;
 };
+/** Creating a property on a non-extensible object is the one [[Set]] failure with its own message. */
+export const rejectAddition = (target, key) => {
+    if (target.extensible)
+        return;
+    throw typeError(`Cannot add property ${String(key)}, object is not extensible.`);
+};
 /** [[DefineOwnProperty]] for a data property, ignoring the chain. */
 export const define = (target, key, value, attrs = data) => {
     const name = canonical(key);
@@ -465,8 +519,13 @@ export const remove = (target, key) => {
     const name = canonical(key);
     if (isIndexed(target)) {
         const at = index(target, name);
-        if (at !== undefined)
-            return target instanceof Bytes ? !(at in target.bytes) : delete target.items[at];
+        if (at !== undefined) {
+            if (target instanceof Bytes)
+                return !(at in target.bytes);
+            if (at in target.items && !target.elements.configurable)
+                return false;
+            return delete target.items[at];
+        }
         if (target instanceof Arr && name === "length")
             return false;
     }

package/dist/stdlib/array.d.ts

@@ -1,5 +1,11 @@
 import { Effect } from "effect";
-import { type Value } from "../interpreter/objects.js";
+import { type Method } from "../interpreter/native.js";
+import { Obj, type Value } from "../interpreter/objects.js";
 import type { Interpreter } from "../interpreter/interpreter.js";
 export declare const sortArray: <R>(ctx: Interpreter<R>, target: Array<Value>, comparator: Value, name: string) => Effect.Effect<Array<Value>, unknown, R>;
 export declare const arrayGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+/**
+ * The callback methods Array and Uint8Array share. They fix the iteration length while reading existing elements
+ * live; `wrap` builds the collection `map` and `filter` return.
+ */
+export declare const callbackMethods: <R, T extends Obj>(ctx: Interpreter<R>, label: string, self: (thisValue: Value, name: string) => T, elements: (target: T) => ArrayLike<Value>, wrap: (values: Array<Value>) => Value) => Array<Method>;

package/dist/stdlib/array.js

@@ -2,9 +2,9 @@ import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interpreter/limits.js";
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
-import { define, get, hidden, Arr, GeneratorObj, hostIterator, Obj, PromiseObj, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
+import { define, get, hidden, Arr, GeneratorObj, hostIterator, Obj, PromiseObj, coerceToInteger, coerceToNumber, coerceToString, rejectAddition, } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
-import { applyCollectionCallback, invoke, preserveConsumerError } from "../interpreter/callback.js";
+import { applyCollectionCallback, invoke, preserveConsumerError, withPrimitives } from "../interpreter/callback.js";
 import { compareText } from "../tool-runtime.js";
 const arrayLikeSource = (source) => {
     // JS would treat a promise as an empty array-like; that would hide a missing `await`.
@@ -29,7 +29,7 @@ const arrayFrom = (ctx, args) => {
             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]));
+                values.push(apply === undefined ? item : yield* apply([item, index], args[2]));
             }
             return new Arr(proto, values);
         }
@@ -39,7 +39,9 @@ const arrayFrom = (ctx, args) => {
             const step = yield* cursor.next;
             if (step.done)
                 return new Arr(proto, values);
-            values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor.close, apply([step.value, index])));
+            values.push(apply === undefined
+                ? step.value
+                : yield* preserveConsumerError(cursor.close, apply([step.value, index], args[2])));
             index += 1;
         }
     });
@@ -102,34 +104,40 @@ export const arrayGlobal = (ctx) => {
         ["from", 1, (_, args) => arrayFrom(ctx, args)],
     ]);
     const self = (thisValue, name) => receiver(Arr, thisValue, `Array.prototype.${name}`);
+    // A mutating method fails where its first element write, delete, or `length` write would on a frozen, sealed, or
+    // non-extensible array. `growth` is given by the methods that always write `length`, even when it is 0; holes a
+    // method would fill on a non-extensible array are not checked.
+    const mutable = (target, growth) => {
+        const length = target.items.length;
+        if ((growth ?? 0) > 0)
+            rejectAddition(target, length);
+        if ((growth ?? 0) < 0 && length > 0 && !target.elements.configurable) {
+            throw typeError(`Cannot delete property '${length - 1}'.`);
+        }
+        if (!target.elements.writable && (length > 0 || growth !== undefined)) {
+            throw typeError(`Cannot assign to read only property '${length > 0 ? 0 : "length"}'.`);
+        }
+        return target;
+    };
     const optNumber = (value) => (value === undefined ? undefined : coerceToInteger(value));
-    // Callback methods fix the iteration length while reading existing elements live.
-    const iterate = (name, length, body) => [
-        name,
-        length,
-        (thisValue, args) => {
-            const target = self(thisValue, name);
-            return body(target.items, target, applyCollectionCallback(ctx, args[0], `Array.${name}`), args);
-        },
-    ];
     methods(builtins, proto, [
         [
             "join",
             1,
             (thisValue, args) => {
-                const joined = self(thisValue, "join")
-                    .items.map((item) => coerceToString(item ?? ""))
-                    .join(args[0] === undefined ? "," : coerceToString(args[0]));
-                checkStringLength(joined.length);
-                return joined;
+                // .map would keep holes, which Effect.forEach would then hand to the body as undefined.
+                const parts = Array.from(self(thisValue, "join").items, (item) => item ?? "");
+                return withPrimitives(ctx, "string", [args[0] === undefined ? "," : args[0], ...parts], ([separator, ...items]) => {
+                    const joined = items.map(coerceToString).join(coerceToString(separator));
+                    checkStringLength(joined.length);
+                    return joined;
+                });
             },
         ],
         [
             "toString",
             0,
-            (thisValue) => self(thisValue, "toString")
-                .items.map((item) => coerceToString(item ?? ""))
-                .join(","),
+            (thisValue) => withPrimitives(ctx, "string", Array.from(self(thisValue, "toString").items, (item) => item ?? ""), (items) => items.map(coerceToString).join(",")),
         ],
         [
             "includes",
@@ -144,7 +152,8 @@ export const arrayGlobal = (ctx) => {
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "lastIndexOf").items;
-                return args[1] === undefined ? target.lastIndexOf(args[0]) : target.lastIndexOf(args[0], optNumber(args[1]));
+                // An explicit undefined is a fromIndex of 0, unlike omitting it.
+                return args.length < 2 ? target.lastIndexOf(args[0]) : target.lastIndexOf(args[0], optNumber(args[1]));
             },
         ],
         ["at", 1, (thisValue, args) => self(thisValue, "at").items.at(optNumber(args[0]) ?? 0)],
@@ -177,6 +186,9 @@ export const arrayGlobal = (ctx) => {
             0,
             (thisValue) => {
                 const target = self(thisValue, "reverse");
+                // Fewer than two elements means no writes at all, so a frozen one-element array reverses fine.
+                if (target.items.length > 1)
+                    mutable(target);
                 target.items.reverse();
                 return target;
             },
@@ -185,7 +197,7 @@ export const arrayGlobal = (ctx) => {
             "sort",
             1,
             (thisValue, args) => {
-                const target = self(thisValue, "sort");
+                const target = mutable(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;
@@ -225,7 +237,7 @@ export const arrayGlobal = (ctx) => {
             "push",
             1,
             (thisValue, args) => {
-                const target = self(thisValue, "push");
+                const target = mutable(self(thisValue, "push"), args.length);
                 // Validate all insertions before mutating to avoid partial cyclic updates.
                 for (const item of args)
                     rejectCircularInsertion(target, item, "Array.push result");
@@ -236,29 +248,28 @@ export const arrayGlobal = (ctx) => {
             "unshift",
             1,
             (thisValue, args) => {
-                const target = self(thisValue, "unshift");
+                const target = mutable(self(thisValue, "unshift"), args.length);
                 for (const item of args)
                     rejectCircularInsertion(target, item, "Array.unshift result");
                 return target.items.unshift(...args);
             },
         ],
-        ["pop", 0, (thisValue) => self(thisValue, "pop").items.pop()],
-        ["shift", 0, (thisValue) => self(thisValue, "shift").items.shift()],
+        ["pop", 0, (thisValue) => mutable(self(thisValue, "pop"), -1).items.pop()],
+        ["shift", 0, (thisValue) => mutable(self(thisValue, "shift"), -1).items.shift()],
         [
             "splice",
             2,
             (thisValue, args) => {
                 const target = self(thisValue, "splice");
-                if (args.length === 0)
-                    return wrap(target.items.splice(0, 0));
+                const length = target.items.length;
                 const start = optNumber(args[0]) ?? 0;
-                if (args.length === 1)
-                    return wrap(target.items.splice(start));
-                const deleteCount = optNumber(args[1]) ?? 0;
+                const from = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+                const deleteCount = args.length === 1 ? length - from : Math.min(Math.max(optNumber(args[1]) ?? 0, 0), length - from);
                 const inserted = args.slice(2);
                 for (const item of inserted)
                     rejectCircularInsertion(target, item, "Array.splice result");
-                return wrap(target.items.splice(start, deleteCount, ...inserted));
+                mutable(target, inserted.length - deleteCount);
+                return wrap(target.items.splice(from, deleteCount, ...inserted));
             },
         ],
         [
@@ -280,7 +291,7 @@ export const arrayGlobal = (ctx) => {
             "fill",
             1,
             (thisValue, args) => {
-                const target = self(thisValue, "fill");
+                const target = mutable(self(thisValue, "fill"));
                 rejectCircularInsertion(target, args[0], "Array.fill result");
                 target.items.fill(args[0], optNumber(args[1]), optNumber(args[2]));
                 return target;
@@ -290,7 +301,7 @@ export const arrayGlobal = (ctx) => {
             "copyWithin",
             2,
             (thisValue, args) => {
-                const target = self(thisValue, "copyWithin");
+                const target = mutable(self(thisValue, "copyWithin"));
                 target.items.copyWithin(optNumber(args[0]) ?? 0, optNumber(args[1]) ?? 0, optNumber(args[2]));
                 return target;
             },
@@ -311,6 +322,50 @@ export const arrayGlobal = (ctx) => {
                 .items.entries()
                 .map(([index, item]) => wrap([index, item]))),
         ],
+        [
+            "flatMap",
+            1,
+            (thisValue, args) => {
+                const target = self(thisValue, "flatMap");
+                const apply = applyCollectionCallback(ctx, args[0], "Array.flatMap");
+                return Effect.gen(function* () {
+                    const length = target.items.length;
+                    const values = [];
+                    for (let index = 0; index < length; index += 1) {
+                        if (!(index in target.items))
+                            continue;
+                        const mapped = yield* apply([target.items[index], index, target], args[1]);
+                        if (mapped instanceof Arr)
+                            values.push(...mapped.items);
+                        else
+                            values.push(mapped);
+                    }
+                    return wrap(values);
+                });
+            },
+        ],
+        ...callbackMethods(ctx, "Array", self, (target) => target.items, wrap),
+    ]);
+    define(proto, IteratorSymbol, get(proto, "values"), hidden);
+    return array;
+};
+/**
+ * The callback methods Array and Uint8Array share. They fix the iteration length while reading existing elements
+ * live; `wrap` builds the collection `map` and `filter` return.
+ */
+export const callbackMethods = (ctx, label, self, elements, wrap) => {
+    const iterate = (name, length, body) => [
+        name,
+        length,
+        (thisValue, args) => {
+            const target = self(thisValue, name);
+            const call = applyCollectionCallback(ctx, args[0], `${label}.${name}`);
+            // reduce and reduceRight take an initial value where the others take a thisArg.
+            const thisArg = name.startsWith("reduce") ? undefined : args[1];
+            return body(elements(target), target, (callbackArgs) => call(callbackArgs, thisArg), args);
+        },
+    ];
+    return [
         iterate("map", 1, (target, receiver, apply) => Effect.gen(function* () {
             const length = target.length;
             const values = [];
@@ -322,20 +377,6 @@ export const arrayGlobal = (ctx) => {
             }
             return wrap(values);
         })),
-        iterate("flatMap", 1, (target, receiver, apply) => Effect.gen(function* () {
-            const length = target.length;
-            const values = [];
-            for (let index = 0; index < length; index += 1) {
-                if (!(index in target))
-                    continue;
-                const mapped = yield* apply([target[index], index, receiver]);
-                if (mapped instanceof Arr)
-                    values.push(...mapped.items);
-                else
-                    values.push(mapped);
-            }
-            return wrap(values);
-        })),
         iterate("filter", 1, (target, receiver, apply) => Effect.gen(function* () {
             const length = target.length;
             const values = [];
@@ -416,7 +457,7 @@ export const arrayGlobal = (ctx) => {
                 while (start < length && !(start in target))
                     start += 1;
                 if (start === length) {
-                    throw typeError("Array.reduce of an empty array with no initial value.");
+                    throw typeError(`${label}.reduce of an empty array with no initial value.`);
                 }
                 accumulator = target[start];
                 start += 1;
@@ -435,7 +476,7 @@ export const arrayGlobal = (ctx) => {
                 while (start >= 0 && !(start in target))
                     start -= 1;
                 if (start < 0) {
-                    throw typeError("Array.reduceRight of an empty array with no initial value.");
+                    throw typeError(`${label}.reduceRight of an empty array with no initial value.`);
                 }
                 accumulator = target[start];
                 start -= 1;
@@ -447,7 +488,5 @@ export const arrayGlobal = (ctx) => {
             }
             return accumulator;
         })),
-    ]);
-    define(proto, IteratorSymbol, get(proto, "values"), hidden);
-    return array;
+    ];
 };

package/dist/stdlib/bytes.js

@@ -4,6 +4,7 @@ import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../i
 import { IteratorSymbol, rangeError, syntaxError, typeError } from "../interpreter/model.js";
 import { define, defineAccessor, get, hidden, Arr, Bytes, hostIterator, Obj, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { describeValue } from "../interpreter/references.js";
+import { callbackMethods, sortArray } from "./array.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)
@@ -110,6 +111,22 @@ export const uint8ArrayGlobal = (ctx) => {
                 return target;
             },
         ],
+        [
+            "sort",
+            1,
+            (thisValue, args) => {
+                const target = self(thisValue, "sort");
+                // Without a comparator, typed arrays sort numerically rather than by string.
+                if (args[0] === undefined) {
+                    target.bytes.sort();
+                    return target;
+                }
+                return Effect.map(sortArray(ctx, [...target.bytes], args[0], "Uint8Array.sort"), (sorted) => {
+                    target.bytes.set(Uint8Array.from(sorted, coerceToNumber));
+                    return target;
+                });
+            },
+        ],
         [
             "indexOf",
             1,
@@ -120,7 +137,7 @@ export const uint8ArrayGlobal = (ctx) => {
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "lastIndexOf").bytes;
-                return args[1] === undefined
+                return args.length < 2
                     ? target.lastIndexOf(coerceToNumber(args[0]))
                     : target.lastIndexOf(coerceToNumber(args[0]), optNumber(args[1]));
             },
@@ -151,6 +168,7 @@ export const uint8ArrayGlobal = (ctx) => {
                 .bytes.entries()
                 .map(([index, byte]) => wrapAll([index, byte]))),
         ],
+        ...callbackMethods(ctx, "Uint8Array", self, (target) => target.bytes, (values) => wrap(Uint8Array.from(values, coerceToNumber))),
     ]);
     define(proto, IteratorSymbol, get(proto, "values"), hidden);
     return uint8Array;

package/dist/stdlib/collections.d.ts

@@ -3,3 +3,5 @@ import type { Interpreter } from "../interpreter/interpreter.js";
 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>;
+export declare const weakMapGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+export declare const weakSetGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;