@opencode/codemode 2.0.15 → 2.0.17

package/dist/interpreter/interpreter.js

@@ -6,14 +6,35 @@ 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, 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 { assign, Callable, define, frozen, get, hostCursor, IteratorObj, has, hidden, hasPrototype, keys, Native, parseArrayIndex, Arguments, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
+import { preserveConsumerError, toPrimitive } 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";
 import { compoundOperators } from "../stdlib/value.js";
+/** The binary operators that convert object operands through ToPrimitive before acting on primitives. */
+const primitiveOperators = new Set([
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "**",
+    "<",
+    "<=",
+    ">",
+    ">=",
+    "&",
+    "|",
+    "^",
+    "<<",
+    ">>",
+    ">>>",
+]);
+/** ToPropertyKey on a primitive (or an opaque value, which keeps its built-in string form). */
+const propertyKey = (value) => typeof value === "string" || typeof value === "number" || typeof value === "symbol" ? value : coerceToString(value);
 // What a loop does with its body's result: exit with a StatementResult, or undefined to keep iterating.
 // Unlabelled break ends this loop; a label the loop does not carry propagates outward.
 const loopExit = (result, labels) => {
@@ -94,6 +115,25 @@ const collectPatternNames = (pattern, out = []) => {
     }
     return out;
 };
+// Whether a function body (or a parameter default) reads `arguments`, looking through arrows but not nested
+// functions, which own theirs. Memoized so the object is only built for calls that can observe it.
+const argumentsUse = new WeakMap();
+const usesArguments = (fn) => {
+    const cached = argumentsUse.get(fn.body);
+    if (cached !== undefined)
+        return cached;
+    const found = [...fn.parameters, fn.body].some(function visit(node) {
+        if (node === null || typeof node !== "object")
+            return false;
+        if (node.type === "Identifier")
+            return node.name === "arguments";
+        if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression")
+            return false;
+        return Object.values(node).some((child) => Array.isArray(child) ? child.some((item) => visit(item)) : visit(child));
+    });
+    argumentsUse.set(fn.body, found);
+    return found;
+};
 // `var` names declared anywhere in a function body except inside nested functions, which own theirs.
 // Memoized per body: a function's var names never change, and hoisting runs on every call.
 const varNames = new WeakMap();
@@ -171,7 +211,8 @@ export class Interpreter {
         this.pending = options.pending;
         this.builtins = options.builtins;
         this.logs = options.logs ?? [];
-        const globalScope = new Map();
+        // Program code has no receiver: top-level `this` is undefined, as in a module.
+        const globalScope = new Map([["this", { mutable: false, value: undefined }]]);
         // Calling back into the program never reads frame state, so any frame serves; the root is always alive.
         this.root = new Frame(this, new ScopeStack([globalScope]));
         for (const [name, value] of [...globals(this), ...(options.globals?.(this) ?? [])]) {
@@ -321,7 +362,7 @@ class Frame {
     }
     createFunction(node, name = node.type === "ArrowFunctionExpression" ? "" : (node.id?.name ?? "")) {
         const builtins = this.ctx.builtins;
-        const fn = new Fn(builtins.Function, name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+        const fn = new Fn(builtins.Function, name, node.params, node.body, this.scopes.capture(), node.async, node.generator, node.type === "ArrowFunctionExpression");
         // Each generator function gets its own prototype, so `g() instanceof g` holds as in JS.
         if (node.generator)
             define(fn, "prototype", new Obj(node.async ? builtins.AsyncGenerator : builtins.Generator), hidden);
@@ -388,9 +429,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 +443,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;
                     }
@@ -852,20 +886,20 @@ class Frame {
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (!(value instanceof Obj)) {
-                    throw typeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern);
+                if (value === null || value === undefined) {
+                    throw typeError(`Cannot destructure ${describeValue(value)} as it is ${value}.`, pattern);
                 }
                 const consumed = new Set();
                 for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
                         const rest = new Obj(self.ctx.builtins.Object);
-                        assign(rest, value, consumed);
+                        assign(rest, enumerableSource(self.ctx, "Object destructuring", value, pattern), consumed);
                         yield* self.declarePattern(property.argument, rest, mutable, property, initialize);
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
                     consumed.add(typeof key === "symbol" ? key : String(key));
-                    yield* self.declarePattern(property.value, self.readProperty(value, key, property), mutable, property, initialize);
+                    yield* self.declarePattern(property.value, self.destructuredProperty(value, key, property), mutable, property, initialize);
                 }
                 return;
             }
@@ -892,20 +926,20 @@ class Frame {
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (!(value instanceof Obj)) {
-                    throw invalidData(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern);
+                if (value === null || value === undefined) {
+                    throw typeError(`Cannot destructure ${describeValue(value)} as it is ${value}.`, pattern);
                 }
                 const consumed = new Set();
                 for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
                         const rest = new Obj(self.ctx.builtins.Object);
-                        assign(rest, value, consumed);
+                        assign(rest, enumerableSource(self.ctx, "Object destructuring", value, pattern), consumed);
                         yield* self.assignPattern(property.argument, rest, property);
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
                     consumed.add(typeof key === "symbol" ? key : String(key));
-                    yield* self.assignPattern(property.value, self.readProperty(value, key, property), property);
+                    yield* self.assignPattern(property.value, self.destructuredProperty(value, key, property), property);
                 }
                 return;
             }
@@ -967,7 +1001,7 @@ class Frame {
         }
         const keyNode = property.key;
         if (property.computed) {
-            return Effect.map(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value));
+            return Effect.flatMap(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value, keyNode));
         }
         if (keyNode.type === "Identifier")
             return Effect.succeed(keyNode.name);
@@ -985,6 +1019,8 @@ class Frame {
             }
             case "Identifier":
                 return Effect.sync(() => this.scopes.get(node.name, node));
+            case "ThisExpression":
+                return Effect.sync(() => this.scopes.get("this", node));
             case "BinaryExpression":
                 return this.evaluateBinaryExpression(node);
             case "LogicalExpression":
@@ -1069,76 +1105,111 @@ class Frame {
             const rhs = yield* self.evaluateExpression(node.right);
             if (operator === "instanceof")
                 return instanceofValue(lhs, rhs, node);
+            if (lhs instanceof Obj || rhs instanceof Obj)
+                return yield* self.applyOperator(operator, lhs, rhs, node);
             return self.applyBinaryOperator(operator, lhs, rhs, node);
         });
     }
+    /** ToPrimitive for an operand: data objects run their own methods; opaque values stay for the data gates below. */
+    toPrimitive(value, hint, node) {
+        return this.native(() => toPrimitive(this.ctx, value, hint), node);
+    }
+    // Arithmetic, relational, and bitwise operators convert both operands first, left then right, so a `valueOf`
+    // runs (and throws) in spec order; `+` asks for the default hint and the rest for a number.
+    applyOperator(operator, lhs, rhs, node) {
+        if (!(lhs instanceof Obj || rhs instanceof Obj))
+            return Effect.succeed(this.applyBinaryOperator(operator, lhs, rhs, node));
+        // IsLooselyEqual converts only an object facing a non-nullish primitive; two objects (including tool
+        // references, which are not Obj) compare by identity.
+        const equality = operator === "==" || operator === "!=";
+        // `in` checks the right operand before ToPropertyKey on the left, so a bad right side wins over a bad key.
+        if (operator === "in" && lhs instanceof Obj && !isOpaque(lhs) && rhs instanceof Obj) {
+            return Effect.map(this.toPropertyKey(lhs, node), (key) => has(rhs, key));
+        }
+        const other = lhs instanceof Obj ? rhs : lhs;
+        const converts = primitiveOperators.has(operator) ||
+            (equality && other !== null && other !== undefined && typeof other !== "object");
+        if (!converts)
+            return Effect.succeed(this.applyBinaryOperator(operator, lhs, rhs, node));
+        const hint = operator === "+" || equality ? "default" : "number";
+        const self = this;
+        return Effect.gen(function* () {
+            const l = yield* self.toPrimitive(lhs, hint, node);
+            const r = yield* self.toPrimitive(rhs, hint, node);
+            return self.applyBinaryOperator(operator, l, r, node);
+        });
+    }
     applyBinaryOperator(operator, lhs, rhs, node) {
         if (operator === "===")
             return lhs === rhs;
         if (operator === "!==")
             return lhs !== rhs;
-        if (operator === "in" && rhs instanceof Obj && !containsOpaqueReference(lhs)) {
-            return has(rhs, lhs !== null && typeof lhs === "object" ? coerceToString(lhs) : lhs);
-        }
-        if (containsOpaqueReference(lhs) || containsOpaqueReference(rhs)) {
+        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, propertyKey(lhs));
+        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";
-        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);
+        // Object operands were already converted by applyOperator; only primitives reach the arithmetic below.
         switch (operator) {
             case "+": {
-                const sum = l + r;
+                const sum = lhs + rhs;
                 if (typeof sum === "string")
                     checkStringLength(sum.length);
                 return sum;
             }
             case "-":
-                return l - r;
+                return lhs - rhs;
             case "*":
-                return l * r;
+                return lhs * rhs;
             case "/":
-                return l / r;
+                return lhs / rhs;
             case "%":
-                return l % r;
+                return lhs % rhs;
             case "**":
-                return l ** r;
-            case "==":
-                return bothObjects ? lhs === rhs : l == r;
-            case "!=":
-                return bothObjects ? lhs !== rhs : l != r;
+                return lhs ** rhs;
             case "<":
-                return l < r;
+                return lhs < rhs;
             case "<=":
-                return l <= r;
+                return lhs <= rhs;
             case ">":
-                return l > r;
+                return lhs > rhs;
             case ">=":
-                return l >= r;
+                return lhs >= rhs;
             case "&":
-                return l & r;
+                return lhs & rhs;
             case "|":
-                return l | r;
+                return lhs | rhs;
             case "^":
-                return l ^ r;
+                return lhs ^ rhs;
             case "<<":
-                return l << r;
+                return lhs << rhs;
             case ">>":
-                return l >> r;
+                return lhs >> rhs;
             case ">>>":
-                return l >>> r;
+                return lhs >>> rhs;
             case "in":
-                if (!(rhs instanceof Obj)) {
-                    throw typeError("The 'in' operator requires a data object on the right-hand side.", node);
-                }
-                return has(rhs, coerceOperand(lhs));
+                throw typeError("The 'in' operator requires a data object on the right-hand side.", node);
             default:
                 throw typeError(`Unsupported binary operator '${operator}'.`, node);
         }
     }
+    // IsLooselyEqual: objects (including functions and tool references) compare by identity, and a nullish
+    // primitive never equals an object.
+    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 primitive = lhsObject ? rhs : lhs;
+        if (primitive === null || primitive === undefined)
+            return false;
+        // Data objects were converted by applyOperator, so only an opaque reference facing a primitive gets here.
+        throw invalidData("Binary operators require data values.", node);
+    }
     evaluateLogicalExpression(node) {
         const operator = node.operator;
         return Effect.flatMap(this.evaluateExpression(node.left), (left) => {
@@ -1160,17 +1231,19 @@ class Frame {
         if (operator === "typeof" && argument.type === "Identifier" && !this.scopes.resolve(argument.name)) {
             return Effect.succeed("undefined");
         }
-        return Effect.map(this.evaluateExpression(argument), (value) => {
+        const self = this;
+        return Effect.gen(function* () {
+            const value = yield* self.evaluateExpression(argument);
             if (operator === "typeof")
                 return typeofValue(value);
             if (operator === "!")
                 return !value;
             if (operator === "void")
                 return undefined;
-            if (containsOpaqueReference(value)) {
+            const operand = yield* self.toPrimitive(value, "number", node);
+            if (isOpaque(operand)) {
                 throw invalidData("Unary operators require data values.", node);
             }
-            const operand = value instanceof Obj ? value.toPrimitive("number") : value;
             let result;
             switch (operator) {
                 case "+":
@@ -1191,11 +1264,16 @@ class Frame {
     evaluateAssignmentExpression(node) {
         const left = node.left;
         const operator = node.operator;
+        // The binary operator a compound assignment applies: `+=` is `+`.
+        const binary = operator.slice(0, -1);
         const self = this;
         return Effect.gen(function* () {
             if (operator === "??=" || operator === "||=" || operator === "&&=") {
                 return yield* self.evaluateLogicalAssignment(node, left, operator);
             }
+            if (operator !== "=" && !compoundOperators.has(operator)) {
+                throw typeError(`Unsupported assignment operator '${operator}'.`, node);
+            }
             if (operator === "=" && (left.type === "ObjectPattern" || left.type === "ArrayPattern")) {
                 const rightValue = yield* self.evaluateExpression(node.right);
                 yield* self.assignPattern(left, rightValue, node);
@@ -1206,17 +1284,23 @@ class Frame {
                 if (operator !== "=") {
                     const current = self.scopes.get(name, left);
                     const rightValue = yield* self.evaluateExpression(node.right);
-                    return self.scopes.set(name, self.applyCompoundAssignment(operator, current, rightValue, node), left);
+                    const next = current instanceof Obj || rightValue instanceof Obj
+                        ? yield* self.applyOperator(binary, current, rightValue, node)
+                        : self.applyBinaryOperator(binary, current, rightValue, node);
+                    return self.scopes.set(name, next, left);
                 }
                 const rightValue = yield* self.evaluateNamed(node.right, name);
                 return self.scopes.set(name, rightValue, left);
             }
             if (left.type === "MemberExpression") {
-                return yield* self.modifyMember(left, (current) => Effect.map(self.evaluateExpression(node.right), (rightValue) => {
+                return yield* self.modifyMember(left, (current) => Effect.flatMap(self.evaluateExpression(node.right), (rightValue) => {
                     if (operator === "=")
-                        return { write: true, next: rightValue, result: rightValue };
-                    const next = self.applyCompoundAssignment(operator, current, rightValue, node);
-                    return { write: true, next, result: next };
+                        return Effect.succeed({ write: true, next: rightValue, result: rightValue });
+                    return Effect.map(self.applyOperator(binary, current, rightValue, node), (next) => ({
+                        write: true,
+                        next,
+                        result: next,
+                    }));
                 }));
             }
             throw typeError("Assignment target must be an Identifier or MemberExpression.", left);
@@ -1254,29 +1338,32 @@ class Frame {
         if (increment === undefined) {
             throw typeError(`Unsupported update operator '${operator}'.`, node);
         }
-        // CodeMode numeric coercion, not host Number(): null-prototype data objects would make
-        // the host throw during ToPrimitive, and opaque runtime references must reject clearly.
+        // CodeMode numeric coercion, not host Number(), so opaque runtime references reject clearly.
         const operand = (current) => {
-            if (containsOpaqueReference(current)) {
+            if (isOpaque(current)) {
                 throw invalidData(`'${operator}' requires a data value.`, argument);
             }
             return coerceToNumber(current);
         };
         if (argument.type === "Identifier") {
-            return Effect.sync(() => {
-                const name = argument.name;
-                const current = operand(this.scopes.get(name, argument));
-                const next = current + increment;
+            const name = argument.name;
+            const current = this.scopes.get(name, argument);
+            const update = (value) => {
+                const before = operand(value);
+                const next = before + increment;
                 this.scopes.set(name, next, argument);
-                return prefix ? next : current;
-            });
+                return prefix ? next : before;
+            };
+            if (!(current instanceof Obj))
+                return Effect.sync(() => update(current));
+            return Effect.map(this.toPrimitive(current, "number", argument), update);
         }
         if (argument.type === "MemberExpression") {
-            return this.modifyMember(argument, (current) => {
-                const value = operand(current);
+            return this.modifyMember(argument, (current) => Effect.map(this.toPrimitive(current, "number", argument), (primitive) => {
+                const value = operand(primitive);
                 const next = value + increment;
-                return Effect.succeed({ write: true, next, result: prefix ? next : value });
-            });
+                return { write: true, next, result: prefix ? next : value };
+            }));
         }
         throw typeError("Update target must be an Identifier or MemberExpression.", argument);
     }
@@ -1320,7 +1407,7 @@ class Frame {
                 return yield* self.createToolCallPromise(callable.path, args);
             }
             if (callable instanceof Fn)
-                return yield* self.invokeFunction(callable, args, node);
+                return yield* self.invokeFunction(callable, thisValue, args, node);
             if (callable instanceof Native) {
                 return yield* self.native(() => callable.call(thisValue, args), node);
             }
@@ -1356,15 +1443,26 @@ class Frame {
         });
     }
     // A callback invoked by a built-in runs below the call that invoked the built-in, so the deeper of the two counts.
-    invokeFunction(fn, args, node) {
+    invokeFunction(fn, thisValue, args, node) {
         const self = this;
         return Effect.flatMap(CallSite, (site) => {
             const depth = Math.max(self.depth, site.depth) + 1;
             if (depth > MAX_CALL_DEPTH)
                 throw rangeError("Maximum call stack size exceeded", node);
             const invocation = new Frame(this.ctx, new ScopeStack([...fn.capturedScopes, new Map()]), depth);
-            // Seed all parameters first so defaults cannot fall through to same-named outer bindings.
             const paramScope = invocation.scopes.current();
+            // `this` and `arguments` are scope bindings so arrows resolve them lexically; a parameter named
+            // `arguments` shadows the object, as in JS.
+            if (!fn.arrow)
+                paramScope.set("this", { mutable: false, value: thisValue, initialized: true });
+            if (!fn.arrow && usesArguments(fn)) {
+                paramScope.set("arguments", {
+                    mutable: true,
+                    value: new Arguments(self.ctx.builtins.Object, args),
+                    initialized: true,
+                });
+            }
+            // Seed all parameters first so defaults cannot fall through to same-named outer bindings.
             for (const parameter of fn.parameters) {
                 for (const name of collectPatternNames(parameter)) {
                     paramScope.set(name, { mutable: true, value: undefined, initialized: false });
@@ -1616,13 +1714,13 @@ class Frame {
                 const keyNode = property.key;
                 let key;
                 if (property.computed) {
-                    key = self.toPropertyKey(yield* self.evaluateExpression(keyNode));
+                    key = yield* self.toPropertyKey(yield* self.evaluateExpression(keyNode), keyNode);
                 }
                 else if (keyNode.type === "Identifier") {
                     key = keyNode.name;
                 }
                 else if (keyNode.type === "Literal") {
-                    key = self.toPropertyKey(literal(keyNode));
+                    key = propertyKey(literal(keyNode));
                 }
                 else {
                     throw typeError("Unsupported object property key shape.", keyNode);
@@ -1682,7 +1780,7 @@ class Frame {
                 checkStringLength(output.length);
                 if (index < expressions.length) {
                     const raw = yield* self.evaluateExpression(expressions[index]);
-                    output += coerceToString(raw);
+                    output += coerceToString(yield* self.toPrimitive(raw, "string", expressions[index]));
                     checkStringLength(output.length);
                 }
             }
@@ -1713,12 +1811,6 @@ class Frame {
     evaluateConditionalExpression(node) {
         return Effect.flatMap(this.evaluateExpression(node.test), (test) => this.evaluateExpression(test ? node.consequent : node.alternate));
     }
-    applyCompoundAssignment(operator, current, incoming, node) {
-        if (!compoundOperators.has(operator)) {
-            throw typeError(`Unsupported assignment operator '${operator}'.`, node);
-        }
-        return this.applyBinaryOperator(operator.slice(0, -1), current, incoming, node);
-    }
     getMemberReference(node) {
         const objectNode = node.object;
         const propertyNode = node.property;
@@ -1733,36 +1825,52 @@ class Frame {
                 return OptionalShortCircuit;
             if ((objectValue === null || objectValue === undefined) && node.optional)
                 return OptionalShortCircuit;
-            const key = node.computed
-                ? self.toPropertyKey(yield* self.evaluateExpression(propertyNode))
-                : propertyNode.type === "Identifier"
-                    ? propertyNode.name
-                    : self.toPropertyKey(yield* self.evaluateExpression(propertyNode));
-            if (objectValue instanceof ToolReference) {
-                if (typeof key !== "string") {
-                    throw typeError("Tool paths must use string property names.", propertyNode);
-                }
-                return new ToolReference([...objectValue.path, key]);
-            }
-            if (objectValue instanceof Obj)
-                return { target: objectValue, key, receiver: objectValue };
-            // Strings own length and indexes; every other primitive property reads through the wrapper prototype.
-            if (typeof objectValue === "string") {
-                if (key === "length")
-                    return { value: objectValue.length };
-                const index = typeof key === "symbol" ? undefined : parseArrayIndex(key);
-                if (index !== undefined)
-                    return { value: objectValue[index] };
-            }
-            const proto = primitivePrototype(self.ctx.builtins, objectValue);
-            if (proto !== undefined)
-                return { target: proto, key, receiver: objectValue };
+            const keyValue = !node.computed && propertyNode.type === "Identifier"
+                ? propertyNode.name
+                : yield* self.evaluateExpression(propertyNode);
+            // GetValue applies ToObject to the base before ToPropertyKey, so a nullish base throws before the key's own
+            // toString runs.
             if (objectValue === null || objectValue === undefined) {
-                throw typeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode);
+                throw typeError(`Cannot read properties of ${objectValue} (reading '${coerceToString(keyValue)}').`, objectNode);
             }
-            throw typeError("Cannot access a property on a non-object value.", objectNode);
+            const key = yield* self.toPropertyKey(keyValue, propertyNode);
+            return self.resolveProperty(objectValue, key, objectNode, propertyNode);
         });
     }
+    resolveProperty(objectValue, key, objectNode, propertyNode) {
+        if (objectValue instanceof ToolReference) {
+            if (typeof key !== "string") {
+                throw typeError("Tool paths must use string property names.", propertyNode);
+            }
+            return new ToolReference([...objectValue.path, key]);
+        }
+        if (objectValue instanceof Obj)
+            return { target: objectValue, key, receiver: objectValue };
+        // Strings own length and indexes; every other primitive property reads through the wrapper prototype.
+        if (typeof objectValue === "string") {
+            if (key === "length")
+                return { value: objectValue.length };
+            const index = typeof key === "symbol" ? undefined : parseArrayIndex(key);
+            if (index !== undefined)
+                return { value: objectValue[index] };
+        }
+        const proto = primitivePrototype(this.ctx.builtins, objectValue);
+        if (proto !== undefined)
+            return { target: proto, key, receiver: objectValue };
+        if (objectValue === null || objectValue === undefined) {
+            throw typeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode);
+        }
+        throw typeError("Cannot access a property on a non-object value.", objectNode);
+    }
+    // One destructured property, read the way a member expression would read it (primitives use their prototype).
+    destructuredProperty(source, key, node) {
+        const reference = this.resolveProperty(source, key, node, node);
+        if (reference instanceof ToolReference)
+            return reference;
+        if ("value" in reference)
+            return reference.value;
+        return this.readProperty(reference.target, reference.key, node, reference.receiver);
+    }
     readReference(reference, node) {
         // Reject unknown promise properties so a missing await cannot hide.
         if (reference.target instanceof PromiseObj && !has(reference.target, reference.key)) {
@@ -1841,14 +1949,13 @@ 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.
-    toPropertyKey(value) {
-        if (typeof value === "string" || typeof value === "number" || typeof value === "symbol")
-            return value;
-        return coerceToString(value);
+    // ToPropertyKey: a data object converts through its own `toString`/`valueOf` first; anything else becomes its
+    // string form synchronously, so `counts[row.category]` works when the field is null.
+    toPropertyKey(value, node) {
+        if (!(value instanceof Obj))
+            return Effect.succeed(propertyKey(value));
+        return Effect.map(this.toPrimitive(value, "string", node), propertyKey);
     }
 }

package/dist/interpreter/intrinsics.d.ts

@@ -2,7 +2,7 @@ import { ErrorObj, Obj, type Value } from "./objects.js";
 export declare const errorTypes: readonly ["Error", "TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "AggregateError"];
 export type ErrorType = (typeof errorTypes)[number];
 export declare const isErrorType: (name: string) => name is ErrorType;
-declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "URL", "URLSearchParams", "Headers", "Uint8Array", "TextEncoder", "TextDecoder", "Promise", "Iterator", "IteratorHelper", "AsyncIterator", "Generator", "AsyncGenerator"];
+declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "WeakMap", "WeakSet", "URL", "URLSearchParams", "Headers", "Uint8Array", "TextEncoder", "TextDecoder", "Promise", "Iterator", "IteratorHelper", "AsyncIterator", "Generator", "AsyncGenerator"];
 /**
  * The built-in prototype objects of one runtime, allocated empty in dependency order. The globals populate them
  * and attach their constructors when the runtime is built.

package/dist/interpreter/intrinsics.js

@@ -22,6 +22,8 @@ const builtins = [
     "RegExp",
     "Map",
     "Set",
+    "WeakMap",
+    "WeakSet",
     "URL",
     "URLSearchParams",
     "Headers",
@@ -78,6 +80,8 @@ export const createBuiltins = () => {
         RegExp: plain(),
         Map: plain(),
         Set: plain(),
+        WeakMap: plain(),
+        WeakSet: plain(),
         URL: plain(),
         URLSearchParams: plain(),
         Headers: plain(),

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, 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, 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;