@opencode/codemode 2.0.15 → 2.0.16

package/dist/interpreter/globals.js

@@ -14,7 +14,7 @@ import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js";
 import { headersGlobal } from "../stdlib/headers.js";
 import { iteratorGlobals } from "../stdlib/iterator.js";
 import { coercion } from "../stdlib/value.js";
-import { base64Global, cryptoGlobal } from "../stdlib/web.js";
+import { base64Global, cryptoGlobal, structuredCloneGlobal } from "../stdlib/web.js";
 import { ToolReference } from "../tool-runtime.js";
 import { errorGlobal } from "./errors.js";
 import { errorTypes } from "./intrinsics.js";
@@ -85,6 +85,7 @@ const table = {
     atob: (ctx) => base64Global(ctx, "atob"),
     btoa: (ctx) => base64Global(ctx, "btoa"),
     crypto: (ctx) => cryptoGlobal(ctx),
+    structuredClone: (ctx) => structuredCloneGlobal(ctx),
     ...Object.fromEntries(errorTypes.map((type) => [type, (ctx) => errorGlobal(type, ctx)])),
 };
 /** Names bound in every program before extensions apply. */

package/dist/interpreter/interpreter.js

@@ -9,7 +9,7 @@ import { globals } from "./globals.js";
 import { assign, Callable, define, frozen, get, hostCursor, IteratorObj, has, hidden, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
 import { preserveConsumerError } from "./callback.js";
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js";
-import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
+import { describeValue, isOpaque, rejectCircularInsertion, typeofValue } from "./references.js";
 import { ScopeStack } from "./scope.js";
 import { constructRegExp } from "../stdlib/regexp.js";
 import { enumerableSource } from "../stdlib/object.js";
@@ -388,9 +388,6 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             const discriminant = yield* self.evaluateExpression(node.discriminant);
-            if (containsOpaqueReference(discriminant)) {
-                throw invalidData("Switch discriminants must be data values.", node);
-            }
             self.scopes.push();
             return yield* Effect.gen(function* () {
                 const cases = node.cases;
@@ -405,11 +402,7 @@ class Frame {
                         defaultIndex = index;
                         continue;
                     }
-                    const candidate = yield* self.evaluateExpression(test);
-                    if (containsOpaqueReference(candidate)) {
-                        throw invalidData("Switch case values must be data values.", test);
-                    }
-                    if (candidate === discriminant) {
+                    if ((yield* self.evaluateExpression(test)) === discriminant) {
                         selected = index;
                         break;
                     }
@@ -1077,16 +1070,19 @@ class Frame {
             return lhs === rhs;
         if (operator === "!==")
             return lhs !== rhs;
-        if (operator === "in" && rhs instanceof Obj && !containsOpaqueReference(lhs)) {
+        if (operator === "==")
+            return this.looselyEqual(lhs, rhs, node);
+        if (operator === "!=")
+            return !this.looselyEqual(lhs, rhs, node);
+        if (operator === "in" && rhs instanceof Obj && !isOpaque(lhs)) {
             return has(rhs, lhs !== null && typeof lhs === "object" ? coerceToString(lhs) : lhs);
         }
-        if (containsOpaqueReference(lhs) || containsOpaqueReference(rhs)) {
+        if (isOpaque(lhs) || isOpaque(rhs)) {
             throw invalidData("Binary operators require data values.", node);
         }
-        // Addition and loose equality use the default hint; every other operator asks for a number.
-        const hint = operator === "+" || operator === "==" || operator === "!=" ? "default" : "number";
+        // Addition uses the default hint; every other operator asks for a number.
+        const hint = operator === "+" ? "default" : "number";
         const coerceOperand = (operand) => (operand instanceof Obj ? operand.toPrimitive(hint) : operand);
-        const bothObjects = lhs !== null && typeof lhs === "object" && rhs !== null && typeof rhs === "object";
         const l = coerceOperand(lhs);
         const r = coerceOperand(rhs);
         switch (operator) {
@@ -1106,10 +1102,6 @@ class Frame {
                 return l % r;
             case "**":
                 return l ** r;
-            case "==":
-                return bothObjects ? lhs === rhs : l == r;
-            case "!=":
-                return bothObjects ? lhs !== rhs : l != r;
             case "<":
                 return l < r;
             case "<=":
@@ -1139,6 +1131,22 @@ class Frame {
                 throw typeError(`Unsupported binary operator '${operator}'.`, node);
         }
     }
+    // IsLooselyEqual: objects (including functions and tool references) compare by identity, and only a
+    // data object facing a non-nullish primitive needs to coerce, so an opaque value is rejected only there.
+    looselyEqual(lhs, rhs, node) {
+        const lhsObject = lhs !== null && typeof lhs === "object";
+        const rhsObject = rhs !== null && typeof rhs === "object";
+        if (lhsObject === rhsObject)
+            return lhsObject ? lhs === rhs : lhs == rhs;
+        const object = lhsObject ? lhs : rhs;
+        const primitive = lhsObject ? rhs : lhs;
+        if (primitive === null || primitive === undefined)
+            return false;
+        if (!(object instanceof Obj) || isOpaque(object)) {
+            throw invalidData("Binary operators require data values.", node);
+        }
+        return object.toPrimitive("default") == primitive;
+    }
     evaluateLogicalExpression(node) {
         const operator = node.operator;
         return Effect.flatMap(this.evaluateExpression(node.left), (left) => {
@@ -1167,7 +1175,7 @@ class Frame {
                 return !value;
             if (operator === "void")
                 return undefined;
-            if (containsOpaqueReference(value)) {
+            if (isOpaque(value)) {
                 throw invalidData("Unary operators require data values.", node);
             }
             const operand = value instanceof Obj ? value.toPrimitive("number") : value;
@@ -1257,7 +1265,7 @@ class Frame {
         // CodeMode numeric coercion, not host Number(): null-prototype data objects would make
         // the host throw during ToPrimitive, and opaque runtime references must reject clearly.
         const operand = (current) => {
-            if (containsOpaqueReference(current)) {
+            if (isOpaque(current)) {
                 throw invalidData(`'${operator}' requires a data value.`, argument);
             }
             return coerceToNumber(current);
@@ -1841,8 +1849,6 @@ class Frame {
         })();
         if (written)
             return;
-        if (target instanceof Arr && key === "length")
-            throw rangeError("Invalid array length", node);
         throw typeError(`Cannot assign to read only property '${String(key)}'.`, node);
     }
     // ToPropertyKey: anything else becomes its string form, so `counts[row.category]` works when the field is null.

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;
@@ -232,6 +236,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;
@@ -363,10 +367,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 +409,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 +460,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 +484,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,7 +2,7 @@ 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 { compareText } from "../tool-runtime.js";
@@ -102,16 +102,22 @@ 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",
@@ -144,7 +150,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 +184,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 +195,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 +235,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 +246,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 +289,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 +299,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 +320,47 @@ 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]);
+                        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);
+            return body(elements(target), target, applyCollectionCallback(ctx, args[0], `${label}.${name}`), args);
+        },
+    ];
+    return [
         iterate("map", 1, (target, receiver, apply) => Effect.gen(function* () {
             const length = target.length;
             const values = [];
@@ -322,20 +372,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 +452,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 +471,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 +483,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/object.js

@@ -1,7 +1,8 @@
 import { Effect } from "effect";
 import { constructor, methods, receiver } from "../interpreter/native.js";
-import { AsyncIteratorSymbol, invalidData, IteratorSymbol, rangeError, typeError, } from "../interpreter/model.js";
-import { define, entries, enumerableKeys, getOwn, hasOwn, hasPrototype, hidden, keys, own, Arr, Obj, PromiseObj, set, coerceToString, } from "../interpreter/objects.js";
+import { AsyncIteratorSymbol, invalidData, IteratorSymbol, typeError } from "../interpreter/model.js";
+import { define, entries, enumerableKeys, getOwn, hasOwn, hasPrototype, hidden, keys, own, ownKeys, Arr, Bytes, Obj, PromiseObj, set, coerceToString, } from "../interpreter/objects.js";
+import { primitivePrototype } from "../interpreter/intrinsics.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion } from "../interpreter/references.js";
 import { invoke, preserveConsumerError } from "../interpreter/callback.js";
 import { ToolReference } from "../tool-runtime.js";
@@ -37,8 +38,6 @@ export const objectAssign = (ctx, args) => {
         for (const key of enumerableKeys(from)) {
             rejectCircularInsertion(target, getOwn(from, key), "Object.assign result", seen);
             if (!set(target, key, getOwn(from, key))) {
-                if (target instanceof Arr && key === "length")
-                    throw rangeError("Invalid array length");
                 throw typeError(`Cannot assign to read only property '${String(key)}'.`);
             }
         }
@@ -81,6 +80,38 @@ const classTag = (value) => {
     return "Object";
 };
 const propertyKey = (value) => value === AsyncIteratorSymbol || value === IteratorSymbol ? value : coerceToString(value);
+// SetIntegrityLevel: primitives pass through. A typed array's bytes cannot carry attributes, so JS throws after
+// already making it non-extensible.
+const restrict = (level, value) => {
+    if (!(value instanceof Obj))
+        return value;
+    value.extensible = false;
+    if (level === "preventExtensions")
+        return value;
+    if (value instanceof Bytes && value.bytes.length > 0) {
+        throw typeError(`Cannot ${level} array buffer views with elements.`);
+    }
+    for (const slot of value.props.values()) {
+        slot.configurable = false;
+        if (level === "freeze" && "value" in slot)
+            slot.writable = false;
+    }
+    if (value instanceof Arr)
+        value.elements = { writable: level === "seal", enumerable: true, configurable: false };
+    return value;
+};
+// TestIntegrityLevel: array elements and `length` answer through `own`, so a non-extensible empty array is sealed
+// but not frozen, as in JS.
+const integrity = (value, frozen) => {
+    if (!(value instanceof Obj))
+        return true;
+    if (value.extensible)
+        return false;
+    return ownKeys(value).every((key) => {
+        const slot = own(value, key);
+        return slot !== undefined && !slot.configurable && !(frozen && "value" in slot && slot.writable);
+    });
+};
 // Object constructs identically with or without new, like JS. Only `keys` copies its result into the
 // program; `values`, `entries`, `assign`, and `fromEntries` hand back the program's own values.
 export const objectGlobal = (ctx) => {
@@ -118,18 +149,41 @@ export const objectGlobal = (ctx) => {
             (_, args) => new Arr(builtins.Array, entries(enumerableSource(ctx, "Object.entries(...)", args[0])).map((entry) => new Arr(builtins.Array, entry))),
         ],
         ["hasOwn", 2, (_, args) => hasOwn(enumerableSource(ctx, "Object.hasOwn(...)", args[0]), propertyKey(args[1]))],
+        ["is", 2, (_, args) => Object.is(args[0], args[1])],
+        ["assign", 2, (_, args) => objectAssign(ctx, args)],
+        ["fromEntries", 1, (_, args) => objectFromEntries(ctx, args[0])],
+        ["freeze", 1, (_, args) => restrict("freeze", args[0])],
+        ["seal", 1, (_, args) => restrict("seal", args[0])],
+        ["preventExtensions", 1, (_, args) => restrict("preventExtensions", args[0])],
+        ["isFrozen", 1, (_, args) => integrity(args[0], true)],
+        ["isSealed", 1, (_, args) => integrity(args[0], false)],
+        ["isExtensible", 1, (_, args) => args[0] instanceof Obj && args[0].extensible],
         [
-            "is",
+            "getPrototypeOf",
+            1,
+            (_, args) => {
+                if (args[0] instanceof Obj)
+                    return args[0].proto;
+                const proto = primitivePrototype(builtins, args[0]);
+                if (proto === undefined) {
+                    throw typeError(`Object.getPrototypeOf cannot convert ${describeValue(args[0])} to an object.`);
+                }
+                return proto;
+            },
+        ],
+        [
+            "create",
             2,
             (_, args) => {
-                if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
-                    throw invalidData("Object.is requires data values.");
+                if (args[0] !== null && !(args[0] instanceof Obj)) {
+                    throw typeError("Object prototype may only be an Object or null.");
+                }
+                if (args[1] !== undefined) {
+                    throw typeError("Object.create property descriptors are not supported; assign the fields after creating the object.");
                 }
-                return Object.is(args[0], args[1]);
+                return new Obj(args[0]);
             },
         ],
-        ["assign", 2, (_, args) => objectAssign(ctx, args)],
-        ["fromEntries", 1, (_, args) => objectFromEntries(ctx, args[0])],
     ]);
     define(object, "groupBy", groupBy(ctx, "Object"), hidden);
     methods(builtins, builtins.Object, [

package/dist/stdlib/web.d.ts

@@ -1,4 +1,5 @@
 import { Obj } from "../interpreter/objects.js";
 import type { Interpreter } from "../interpreter/interpreter.js";
 export declare const base64Global: <R>(ctx: Interpreter<R>, name: "atob" | "btoa") => import("../interpreter/objects.js").Native<R>;
+export declare const structuredCloneGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
 export declare const cryptoGlobal: <R>(ctx: Interpreter<R>) => Obj;

package/dist/stdlib/web.js

@@ -1,7 +1,9 @@
 import { fn, methods } from "../interpreter/native.js";
 import { typeError } from "../interpreter/model.js";
-import { Bytes, Obj, coerceToString } from "../interpreter/objects.js";
+import { define, entries, get, getOwn, hasOwn, hidden, isRuntimeReference, Arr, Bytes, DateObj, ErrorObj, MapObj, Obj, RegExpObj, SetObj, coerceToString, } from "../interpreter/objects.js";
+import { createErrorValue, isErrorType } from "../interpreter/intrinsics.js";
 import { describeValue } from "../interpreter/references.js";
+import { ToolReference } from "../tool-runtime.js";
 // WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies. Invalid input is a
 // TypeError as well; browsers throw a DOMException named InvalidCharacterError, which CodeMode does not have.
 export const base64Global = (ctx, name) => fn(ctx.builtins, name, 1, (_, args) => {
@@ -15,6 +17,65 @@ export const base64Global = (ctx, name) => fn(ctx.builtins, name, 1, (_, args) =
         throw typeError("The string contains invalid characters.");
     }
 });
+// HTML structured clone over CodeMode's data kinds. Shared references survive through the memo; prototypes and
+// frozen state do not, as in JS. Without a DOMException, DataCloneError is a TypeError carrying that prefix.
+export const structuredCloneGlobal = (ctx) => fn(ctx.builtins, "structuredClone", 1, (_, args) => {
+    if (args.length === 0)
+        throw typeError("structuredClone requires 1 argument");
+    const builtins = ctx.builtins;
+    const memo = new Map();
+    const clone = (value) => {
+        if (typeof value === "symbol" || value instanceof ToolReference) {
+            throw typeError(`DataCloneError: ${describeValue(value)} could not be cloned.`);
+        }
+        if (!(value instanceof Obj))
+            return value;
+        const seen = memo.get(value);
+        if (seen !== undefined)
+            return seen;
+        const remember = (copy) => {
+            memo.set(value, copy);
+            return copy;
+        };
+        if (value instanceof MapObj) {
+            const copy = remember(new MapObj(builtins.Map));
+            for (const [key, item] of value.map)
+                copy.map.set(clone(key), clone(item));
+            return copy;
+        }
+        if (value instanceof SetObj) {
+            const copy = remember(new SetObj(builtins.Set));
+            for (const item of value.set)
+                copy.set.add(clone(item));
+            return copy;
+        }
+        if (value instanceof DateObj)
+            return remember(new DateObj(builtins.Date, value.time));
+        if (value instanceof RegExpObj) {
+            return remember(new RegExpObj(builtins.RegExp, value.regex.source, value.regex.flags));
+        }
+        if (value instanceof Bytes)
+            return remember(new Bytes(builtins.Uint8Array, new Uint8Array(value.bytes)));
+        if (value instanceof ErrorObj) {
+            const name = get(value, "name");
+            const message = get(value, "message");
+            const copy = remember(createErrorValue(builtins[typeof name === "string" && isErrorType(name) ? name : "Error"], message === undefined ? undefined : coerceToString(message)));
+            const stack = getOwn(value, "stack");
+            if (typeof stack === "string")
+                define(copy, "stack", stack, hidden);
+            if (hasOwn(value, "cause"))
+                define(copy, "cause", clone(getOwn(value, "cause")), hidden);
+            return copy;
+        }
+        if (isRuntimeReference(value))
+            throw typeError(`DataCloneError: ${describeValue(value)} could not be cloned.`);
+        const copy = remember(value instanceof Arr ? new Arr(builtins.Array, new Array(value.items.length)) : new Obj(builtins.Object));
+        for (const [key, item] of entries(value))
+            define(copy, key, clone(item));
+        return copy;
+    };
+    return clone(args[0]);
+});
 export const cryptoGlobal = (ctx) => {
     const object = new Obj(ctx.builtins.Object);
     methods(ctx.builtins, object, [

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "2.0.15",
+  "version": "2.0.16",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",