@opencode/codemode 2.0.14 → 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.d.ts

@@ -1,9 +1,9 @@
-import type { Program } from "acorn";
+import type { Program, TaggedTemplateExpression } from "acorn";
 import { Effect } from "effect";
 import { type Json } from "../data.js";
 import { type ToolRuntime } from "../tool-runtime.js";
 import { type Builtins } from "./intrinsics.js";
-import { type Cursor, PromiseObj, type Value } from "./objects.js";
+import { type Cursor, Arr, PromiseObj, type Value } from "./objects.js";
 import { Pending } from "./promises.js";
 /** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
 export declare class Interpreter<R> {
@@ -11,6 +11,8 @@ export declare class Interpreter<R> {
     readonly pending: Pending<R>;
     readonly builtins: Builtins;
     readonly logs: Array<string>;
+    /** Template objects by site: a tag sees the same `strings` array every time its literal is evaluated, as in JS. */
+    readonly templates: WeakMap<TaggedTemplateExpression, Arr>;
     private readonly root;
     constructor(options: {
         readonly tools: ToolRuntime<R>;

package/dist/interpreter/interpreter.js

@@ -6,10 +6,10 @@ import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
 import { primitivePrototype } from "./intrinsics.js";
 import { globals } from "./globals.js";
-import { assign, Callable, define, get, hostCursor, IteratorObj, has, hidden, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.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";
@@ -163,6 +163,8 @@ export class Interpreter {
     pending;
     builtins;
     logs;
+    /** Template objects by site: a tag sees the same `strings` array every time its literal is evaluated, as in JS. */
+    templates = new WeakMap();
     root;
     constructor(options) {
         this.tools = options.tools;
@@ -386,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;
@@ -403,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;
                     }
@@ -715,10 +710,10 @@ class Frame {
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
             const right = yield* self.evaluateExpression(node.right);
             const keys = self.enumerableKeys(right, node.right);
-            if (left.type !== "Identifier" && left.type !== "VariableDeclaration") {
+            if (left.type === "RestElement" || left.type === "AssignmentPattern") {
                 throw typeError("Unsupported for...in binding.", left);
             }
-            const assignmentName = left.type === "Identifier" ? left.name : undefined;
+            const assignment = left.type === "VariableDeclaration" ? undefined : left;
             for (const key of keys) {
                 const result = yield* Effect.gen(function* () {
                     if (declared?.lexical) {
@@ -729,8 +724,8 @@ class Frame {
                     else if (declared) {
                         yield* self.assignPattern(declared.pattern, key, left);
                     }
-                    else if (assignmentName) {
-                        self.scopes.set(assignmentName, key, left);
+                    else if (assignment) {
+                        yield* self.assignPattern(assignment, key, left);
                     }
                     return yield* self.evaluateStatement(node.body);
                 }).pipe(Effect.ensuring(Effect.sync(() => {
@@ -1016,6 +1011,8 @@ class Frame {
                 return this.evaluateArrayExpression(node);
             case "TemplateLiteral":
                 return this.evaluateTemplateLiteral(node);
+            case "TaggedTemplateExpression":
+                return this.evaluateTaggedTemplate(node);
             case "ConditionalExpression":
                 return this.evaluateConditionalExpression(node);
             case "UpdateExpression":
@@ -1073,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) {
@@ -1102,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 "<=":
@@ -1135,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) => {
@@ -1163,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;
@@ -1253,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);
@@ -1366,12 +1378,16 @@ class Frame {
                     paramScope.set(name, { mutable: true, value: undefined, initialized: false });
                 }
             }
+            const parameters = fn.parameters.map((parameter) => parameter.type === "Identifier" ? parameter.name : undefined);
             const bind = Effect.gen(function* () {
                 for (const [index, parameter] of fn.parameters.entries()) {
                     if (parameter.type === "RestElement") {
                         yield* invocation.declarePattern(parameter.argument, new Arr(self.ctx.builtins.Array, args.slice(index)), true, parameter, true);
                         break;
                     }
+                    // A sloppy simple parameter list may repeat a name; the last occurrence wins, as in JS.
+                    if (parameter.type === "Identifier" && parameters.lastIndexOf(parameter.name) !== index)
+                        continue;
                     yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
                 }
             });
@@ -1666,7 +1682,7 @@ class Frame {
         return Effect.gen(function* () {
             for (let index = 0; index < quasis.length; index += 1) {
                 const quasi = quasis[index];
-                // acorn only omits `cooked` for invalid escapes in tagged templates, which are unsupported.
+                // acorn only omits `cooked` for invalid escapes, which are a parse error outside a tagged template.
                 if (typeof quasi.value.cooked !== "string") {
                     throw typeError("Invalid template literal quasi.", quasi);
                 }
@@ -1681,6 +1697,27 @@ class Frame {
             return output;
         });
     }
+    // `tag\`a${x}b\`` is `tag(strings, x)`: the tag is read like a callee (a member keeps its receiver), the
+    // substitutions are evaluated in order, and `strings` carries the escaped source as `strings.raw`.
+    evaluateTaggedTemplate(node) {
+        const self = this;
+        return Effect.gen(function* () {
+            const { callable, thisValue } = node.tag.type === "MemberExpression"
+                ? yield* self.readMethod(node.tag)
+                : { callable: yield* self.evaluateExpression(node.tag), thisValue: undefined };
+            const strings = self.ctx.templates.get(node) ?? self.createTemplateObject(node);
+            const values = yield* Effect.forEach(node.quasi.expressions, (expression) => self.evaluateExpression(expression));
+            return yield* self.call(callable, thisValue, [strings, ...values], node, node.tag);
+        });
+    }
+    createTemplateObject(node) {
+        const array = this.ctx.builtins.Array;
+        // An invalid escape such as `\unicode` cooks to `undefined` and survives only in `raw`.
+        const strings = new Arr(array, node.quasi.quasis.map((quasi) => quasi.value.cooked ?? undefined));
+        define(strings, "raw", new Arr(array, node.quasi.quasis.map((quasi) => quasi.value.raw)), frozen);
+        this.ctx.templates.set(node, strings);
+        return strings;
+    }
     evaluateConditionalExpression(node) {
         return Effect.flatMap(this.evaluateExpression(node.test), (test) => this.evaluateExpression(test ? node.consequent : node.alternate));
     }
@@ -1812,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/model.d.ts

@@ -62,7 +62,7 @@ export declare const rangeError: (message: string, node?: AstNode) => PendingThr
 export declare const referenceError: (message: string, node?: AstNode) => PendingThrow;
 export declare const syntaxError: (message: string, node?: AstNode) => PendingThrow;
 export declare const uriError: (message: string, node?: AstNode) => PendingThrow;
-export declare 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, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
+export declare 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 declare const unsupportedSyntax: (kind: string, node: AstNode) => PendingThrow;
 export declare const sourceLocation: (node: AstNode) => {
     readonly line: number;

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, tagged templates, 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, this, 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;
@@ -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/regexp.js

@@ -15,20 +15,16 @@ const flagProperties = [
 const regexFailureReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "");
 const escapeRegexHint = 'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.';
 export const toHostRegex = (arg, method, extraFlags = "") => {
-    // Native parity: an undefined pattern behaves as an empty pattern.
-    if (arg === undefined)
-        return new RegExp("", extraFlags);
     if (arg instanceof RegExpObj)
         return arg.regex;
-    if (typeof arg === "string") {
-        try {
-            return new RegExp(arg, extraFlags);
-        }
-        catch (error) {
-            throw syntaxError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`);
-        }
+    // Anything else is a pattern string, as `new RegExp(arg)` would read it: undefined is the empty pattern.
+    const source = arg === undefined ? "" : coerceToString(arg);
+    try {
+        return new RegExp(source, extraFlags);
+    }
+    catch (error) {
+        throw syntaxError(`String.${method} received the string ${JSON.stringify(source)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`);
     }
-    throw typeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`);
 };
 export const matchToValue = (builtins, match) => {
     const result = new Arr(builtins.Array, Array.from(match, (group) => group));

package/dist/stdlib/string.js

@@ -2,9 +2,9 @@ import { Effect } from "effect";
 import { constructor, fn, methods } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
-import { define, hidden, Arr, hostIterator, RegExpObj, record, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
+import { define, get, hidden, Arr, hostIterator, Obj, RegExpObj, record, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
-import { applyCollectionCallback, isSupportedCallback } from "../interpreter/callback.js";
+import { applyCollectionCallback, isSupportedCallback, toPrimitiveString } from "../interpreter/callback.js";
 import { matchToValue, toHostRegex } from "./regexp.js";
 import { coercion } from "./value.js";
 // console is intercepted by the interpreter before reaching here.
@@ -78,6 +78,25 @@ export const stringGlobal = (ctx) => {
     methods(builtins, string, [
         codeUnits("fromCharCode", String.fromCharCode),
         codeUnits("fromCodePoint", String.fromCodePoint),
+        [
+            "raw",
+            1,
+            (_, args) => {
+                const template = args[0];
+                const raw = template instanceof Obj ? get(template, "raw") : undefined;
+                if (!(raw instanceof Obj))
+                    throw typeError("String.raw expects a template object with a raw array.");
+                const count = Math.max(0, coerceToInteger(get(raw, "length")));
+                checkArrayLength(count);
+                // Each literal is followed by its substitution, except the last literal, or when substitutions run out.
+                const parts = Array.from({ length: count }, (_, index) => index + 1 < count && index + 1 < args.length ? [get(raw, index), args[index + 1]] : [get(raw, index)]).flat();
+                return Effect.map(Effect.forEach(parts, (part) => toPrimitiveString(ctx, part)), (strings) => {
+                    const output = strings.join("");
+                    checkStringLength(output.length);
+                    return output;
+                });
+            },
+        ],
     ]);
     const self = (thisValue, name) => {
         if (typeof thisValue === "string")

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.14",
+  "version": "2.0.16",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",