@opencode/codemode 0.0.0-beta-19422 → 0.0.0-beta-19500

package/dist/interpreter/runtime.js

@@ -1,11 +1,12 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
 import { ToolRuntimeError, toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
-import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, isRecord, IteratorSymbol, IteratorSymbols, OptionalShortCircuit, PromiseInstanceMethodReference, ProgramThrow, unsupportedSyntax, } from "./model.js";
+import { AsyncIteratorSymbol, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, IteratorSymbol, OptionalShortCircuit, PromiseInstanceMethodReference, ProgramThrow, unsupportedSyntax, } from "./model.js";
 import { caughtErrorValue } from "./errors.js";
 import { globals } from "./globals.js";
 import { HostFunction, HostNamespace } from "./host.js";
 import { invokeIntrinsic } from "./methods.js";
+import { assign, get, has, ownKeys, parseArrayIndex, ProgramArray, ProgramFunction, ProgramObject, record, remove, set, } from "./objects.js";
 import { preserveConsumerError } from "./runner.js";
 import { invokePromiseInstanceMethod, PromiseRuntime, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, describeValue, isRuntimeReference, rejectCircularInsertion, typeofValue, } from "./references.js";
@@ -16,15 +17,22 @@ import { numberMethods } from "../stdlib/number.js";
 import { constructRegExp, regexpMethods, regexpProperties } from "../stdlib/regexp.js";
 import { stringMethods } from "../stdlib/string.js";
 import { uriArgument, urlMethods, urlProperties, urlSearchParamsMethods, urlWritableProperties } from "../stdlib/url.js";
-import { coerceToNumber, coerceToString, compoundOperators } from "../stdlib/value.js";
+import { enumerableSource } from "../stdlib/object.js";
+import { coerceToNumber, coerceToString, compoundOperators, errorBrandName } from "../stdlib/value.js";
 import { Values } from "../values.js";
-const MAX_ARRAY_LENGTH = 4_294_967_295;
-const parseArrayIndex = (key) => {
-    const property = String(key);
-    if (!/^(0|[1-9]\d*)$/.test(property))
-        return undefined;
-    const index = Number(property);
-    return index < MAX_ARRAY_LENGTH ? index : undefined;
+// 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) => {
+    if (result.kind === "return")
+        return result;
+    if (result.kind === "break") {
+        if (result.label !== undefined && !labels?.has(result.label))
+            return result;
+        return { kind: "none" };
+    }
+    if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label))
+        return result;
+    return undefined;
 };
 const calleeDescription = (callee) => {
     if (callee?.type === "Identifier")
@@ -42,6 +50,33 @@ const calleeDescription = (callee) => {
     }
     return "The called value";
 };
+const constructorName = (value) => {
+    if (typeof value === "string")
+        return "String";
+    if (typeof value === "number")
+        return "Number";
+    if (typeof value === "boolean")
+        return "Boolean";
+    if (value instanceof ProgramArray)
+        return "Array";
+    if (value instanceof Values.Date)
+        return "Date";
+    if (value instanceof Values.RegExp)
+        return "RegExp";
+    if (value instanceof Values.Map)
+        return "Map";
+    if (value instanceof Values.Set)
+        return "Set";
+    if (value instanceof Values.URL)
+        return "URL";
+    if (value instanceof Values.URLSearchParams)
+        return "URLSearchParams";
+    if (value instanceof Values.Promise)
+        return "Promise";
+    if (!(value instanceof ProgramObject) || value instanceof ProgramFunction)
+        return undefined;
+    return errorBrandName(value) ?? "Object";
+};
 const instanceofValue = (lhs, rhs, node) => {
     if (rhs instanceof HostFunction && rhs.instanceOf !== undefined)
         return rhs.instanceOf(lhs);
@@ -72,6 +107,55 @@ const collectPatternNames = (pattern, out = []) => {
     }
     return out;
 };
+// `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();
+const collectVarNames = (node, out = []) => {
+    if (!node)
+        return out;
+    switch (node.type) {
+        case "VariableDeclaration":
+            if (node.kind === "var")
+                for (const declaration of node.declarations)
+                    collectPatternNames(declaration.id, out);
+            break;
+        case "BlockStatement":
+            for (const statement of node.body)
+                collectVarNames(statement, out);
+            break;
+        case "IfStatement":
+            collectVarNames(node.consequent, out);
+            collectVarNames(node.alternate, out);
+            break;
+        case "ForStatement":
+            if (node.init?.type === "VariableDeclaration")
+                collectVarNames(node.init, out);
+            collectVarNames(node.body, out);
+            break;
+        case "ForInStatement":
+        case "ForOfStatement":
+            if (node.left.type === "VariableDeclaration")
+                collectVarNames(node.left, out);
+            collectVarNames(node.body, out);
+            break;
+        case "WhileStatement":
+        case "DoWhileStatement":
+        case "LabeledStatement":
+            collectVarNames(node.body, out);
+            break;
+        case "SwitchStatement":
+            for (const item of node.cases)
+                for (const statement of item.consequent)
+                    collectVarNames(statement, out);
+            break;
+        case "TryStatement":
+            collectVarNames(node.block, out);
+            collectVarNames(node.handler?.body, out);
+            collectVarNames(node.finalizer, out);
+            break;
+    }
+    return out;
+};
 const loopDeclaration = (left, statement) => {
     if (left.type !== "VariableDeclaration")
         return undefined;
@@ -90,12 +174,6 @@ const isOpaqueMemberReference = (value) => value instanceof ToolReference ||
     value instanceof PromiseInstanceMethodReference ||
     value instanceof IntrinsicReference ||
     value instanceof GeneratorMethodReference;
-const copyIteratorSymbols = (source, target, consumed) => {
-    for (const symbol of IteratorSymbols) {
-        if (!consumed?.has(symbol) && Object.hasOwn(source, symbol))
-            Reflect.set(target, symbol, Reflect.get(source, symbol));
-    }
-};
 const promiseResolutionNode = { type: "PromiseResolution", start: 0, end: 0 };
 /** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
 export class Runtime {
@@ -105,8 +183,10 @@ export class Runtime {
     promises;
     logs;
     runner;
+    /** Built-in globals by name, unaffected by program shadowing. */
+    builtins;
     root;
-    constructor(executeTool, search, toolKeys, promises, logs = []) {
+    constructor(executeTool, search, toolKeys, promises, logs = [], extraGlobals = () => []) {
         this.executeTool = executeTool;
         this.search = search;
         this.toolKeys = toolKeys;
@@ -121,7 +201,8 @@ export class Runtime {
             settlePromise: (promise) => this.root.settlePromise(promise),
             syncIterator: (value, node) => this.root.syncIterator(value, node),
         };
-        for (const [name, value] of globals(this))
+        this.builtins = new Map([...globals(this), ...extraGlobals(this)]);
+        for (const [name, value] of this.builtins)
             globalScope.set(name, { mutable: false, value });
     }
     run(program) {
@@ -145,6 +226,7 @@ class Frame {
         return Effect.gen(function* () {
             self.predeclareLexical(program.body);
             self.hoistFunctions(program.body);
+            self.hoistVars(program.body);
             let value = undefined;
             for (const [index, statement] of program.body.entries()) {
                 if (index === program.body.length - 1 && statement.type === "ExpressionStatement") {
@@ -242,8 +324,15 @@ class Frame {
             return { kind: "none" };
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
-    createFunction(node) {
-        return new CodeModeFunction(node.params, node.body, this.scopes.capture(), node.async, node.generator);
+    createFunction(node, name = node.type === "ArrowFunctionExpression" ? "" : (node.id?.name ?? "")) {
+        return new ProgramFunction(name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+    }
+    // NamedEvaluation: an anonymous function definition takes the name of what it is assigned to.
+    evaluateNamed(node, name) {
+        if (node.type === "ArrowFunctionExpression" || (node.type === "FunctionExpression" && !node.id)) {
+            return Effect.sync(() => this.createFunction(node, name));
+        }
+        return this.evaluateExpression(node);
     }
     hoistFunctions(statements) {
         for (const node of statements) {
@@ -252,6 +341,19 @@ class Frame {
             this.scopes.declare(node.id.name, this.createFunction(node), true, node);
         }
     }
+    // Hoisted `var` bindings start undefined, or copy a same-named parameter. Function bodies hoist
+    // into their own scope above the parameters so closures in parameter defaults keep seeing outer names.
+    hoistVars(statements, parameters) {
+        const names = varNames.get(statements) ??
+            statements.reduce((out, statement) => collectVarNames(statement, out), []);
+        varNames.set(statements, names);
+        const scope = this.scopes.current();
+        for (const name of names) {
+            if (scope.has(name))
+                continue;
+            scope.set(name, { mutable: true, value: parameters?.get(name)?.value, initialized: true });
+        }
+    }
     predeclareLexical(statements) {
         for (const statement of statements) {
             if (statement.type !== "VariableDeclaration")
@@ -287,7 +389,9 @@ class Frame {
             self.scopes.push();
             return yield* Effect.gen(function* () {
                 const cases = node.cases;
-                self.predeclareLexical(cases.flatMap((branch) => branch.consequent));
+                const statements = cases.flatMap((branch) => branch.consequent);
+                self.predeclareLexical(statements);
+                self.hoistFunctions(statements);
                 let defaultIndex;
                 let selected;
                 for (const [index, branch] of cases.entries()) {
@@ -328,20 +432,9 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             while (yield* self.evaluateExpression(node.test)) {
-                const result = yield* self.evaluateStatement(node.body);
-                if (result.kind === "continue") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    continue;
-                }
-                if (result.kind === "break") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "return") {
-                    return result;
-                }
+                const exit = loopExit(yield* self.evaluateStatement(node.body), labels);
+                if (exit !== undefined)
+                    return exit;
             }
             return { kind: "none" };
         });
@@ -350,20 +443,9 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             do {
-                const result = yield* self.evaluateStatement(node.body);
-                if (result.kind === "continue") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    continue;
-                }
-                if (result.kind === "break") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "return") {
-                    return result;
-                }
+                const exit = loopExit(yield* self.evaluateStatement(node.body), labels);
+                if (exit !== undefined)
+                    return exit;
             } while (yield* self.evaluateExpression(node.test));
             return { kind: "none" };
         });
@@ -398,24 +480,13 @@ class Frame {
             };
             nextIteration();
             while (testNode ? yield* self.evaluateExpression(testNode) : true) {
-                const result = yield* self.evaluateStatement(node.body);
-                if (result.kind === "return") {
-                    return result;
-                }
-                if (result.kind === "break") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label))
-                    return result;
+                const exit = loopExit(yield* self.evaluateStatement(node.body), labels);
+                if (exit !== undefined)
+                    return exit;
                 nextIteration();
                 if (updateNode) {
                     yield* self.evaluateExpression(updateNode);
                 }
-                if (result.kind === "continue") {
-                    continue;
-                }
             }
             return { kind: "none" };
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
@@ -446,18 +517,20 @@ class Frame {
             }
             const assignment = left.type === "VariableDeclaration" ? undefined : left;
             const evaluateBody = (value) => Effect.gen(function* () {
-                if (declared) {
+                if (declared?.lexical) {
                     self.scopes.push();
-                    if (declared.lexical)
-                        self.predeclarePattern(declared.pattern, declared.mutable, left);
-                    yield* self.declarePattern(declared.pattern, value, declared.mutable, left, declared.lexical);
+                    self.predeclarePattern(declared.pattern, declared.mutable, left);
+                    yield* self.declarePattern(declared.pattern, value, declared.mutable, left, true);
+                }
+                else if (declared) {
+                    yield* self.assignPattern(declared.pattern, value, left);
                 }
                 else if (assignment) {
                     yield* self.assignPattern(assignment, value, left);
                 }
                 return yield* self.evaluateStatement(node.body);
             }).pipe(Effect.ensuring(Effect.sync(() => {
-                if (declared)
+                if (declared?.lexical)
                     self.scopes.pop();
             })));
             while (true) {
@@ -475,20 +548,10 @@ class Frame {
                     }
                     return yield* Effect.failCause(bodyExit.cause);
                 }
-                const result = bodyExit.value;
-                if (result.kind === "return") {
+                const exit = loopExit(bodyExit.value, labels);
+                if (exit !== undefined) {
                     yield* close();
-                    return result;
-                }
-                if (result.kind === "break") {
-                    yield* close();
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label)) {
-                    yield* close();
-                    return result;
+                    return exit;
                 }
             }
         }).pipe(Effect.ensuring(Effect.sync(() => {
@@ -512,8 +575,8 @@ class Frame {
         });
     }
     syncIterator(value, node) {
-        const iterator = Array.isArray(value)
-            ? value[Symbol.iterator]()
+        const iterator = value instanceof ProgramArray
+            ? value.items[Symbol.iterator]()
             : typeof value === "string"
                 ? value[Symbol.iterator]()
                 : value instanceof Values.Map
@@ -527,7 +590,10 @@ class Frame {
             return Effect.succeed({
                 next: Effect.sync(() => {
                     const step = iterator.next();
-                    return { done: Boolean(step.done), value: step.value };
+                    return {
+                        done: Boolean(step.done),
+                        value: Array.isArray(step.value) ? new ProgramArray(step.value) : step.value,
+                    };
                 }),
                 close: Effect.void,
             });
@@ -550,10 +616,10 @@ class Frame {
                 asynchronous: value.asynchronous,
             });
         }
-        if (!isRecord(value) || isRuntimeReference(value))
+        if (!(value instanceof ProgramObject))
             return Effect.undefined;
-        const asyncMethod = allowAsync ? Reflect.get(value, AsyncIteratorSymbol) : undefined;
-        const method = asyncMethod ?? Reflect.get(value, IteratorSymbol);
+        const asyncMethod = allowAsync ? get(value, AsyncIteratorSymbol) : undefined;
+        const method = asyncMethod ?? get(value, IteratorSymbol);
         if (method === undefined || method === null)
             return Effect.undefined;
         const self = this;
@@ -563,7 +629,7 @@ class Frame {
                 iterator: object,
                 next: object instanceof CodeModeGenerator
                     ? new GeneratorMethodReference(object, "next")
-                    : self.requireIteratorMethod(object.next, "Iterator next", node),
+                    : self.requireIteratorMethod(get(object, "next"), "Iterator next", node),
                 asynchronous: asyncMethod !== undefined && asyncMethod !== null,
             };
         });
@@ -573,7 +639,7 @@ class Frame {
         return Effect.gen(function* () {
             if (iterator.asynchronous) {
                 const object = self.requireIteratorObject(yield* self.awaitValue(yield* self.invokeCallable(iterator.next, [], node)), "Iterator next() result", node);
-                return { done: Boolean(object.done), value: object.value };
+                return { done: Boolean(get(object, "done")), value: get(object, "value") };
             }
             const called = yield* Effect.exit(self.invokeCallable(iterator.next, [], node));
             if (!Exit.isSuccess(called)) {
@@ -583,7 +649,7 @@ class Frame {
             }
             const captured = yield* Effect.exit(Effect.sync(() => {
                 const object = self.requireIteratorObject(called.value, "Iterator next() result", node);
-                return { done: Boolean(object.done), value: object.value };
+                return { done: Boolean(get(object, "done")), value: get(object, "value") };
             }));
             if (!Exit.isSuccess(captured)) {
                 if (awaiting)
@@ -601,7 +667,7 @@ class Frame {
     closeIterator(iterator, node, awaiting = true) {
         const close = iterator.iterator instanceof CodeModeGenerator
             ? new GeneratorMethodReference(iterator.iterator, "return")
-            : iterator.iterator.return;
+            : get(iterator.iterator, "return");
         if (close === undefined || close === null)
             return iterator.asynchronous || !awaiting ? Effect.void : Effect.yieldNow;
         const self = this;
@@ -617,7 +683,7 @@ class Frame {
                     yield* Effect.yieldNow;
                 return yield* Effect.failCause(called.cause);
             }
-            const captured = yield* Effect.exit(Effect.sync(() => self.requireIteratorObject(called.value, "Iterator return() result", node).value));
+            const captured = yield* Effect.exit(Effect.sync(() => get(self.requireIteratorObject(called.value, "Iterator return() result", node), "value")));
             if (!Exit.isSuccess(captured)) {
                 if (awaiting)
                     yield* Effect.yieldNow;
@@ -628,7 +694,7 @@ class Frame {
         });
     }
     requireIteratorObject(value, context, node) {
-        if (isRecord(value) && !isRuntimeReference(value))
+        if (value instanceof ProgramObject)
             return value;
         throw new InterpreterRuntimeError(`${context} must be an object.`, node).as("TypeError");
     }
@@ -642,17 +708,13 @@ class Frame {
             return value;
         throw new InterpreterRuntimeError(`${context} must be a function.`, node).as("TypeError");
     }
-    enumerableKeys(value) {
-        if (value instanceof ToolReference) {
+    // for...in over null/undefined iterates nothing, like JS.
+    enumerableKeys(value, node) {
+        if (value instanceof ToolReference)
             return [...this.runtime.toolKeys(value.path)];
-        }
-        if (Array.isArray(value)) {
-            return Object.keys(value);
-        }
-        if (value !== null && typeof value === "object" && !isRuntimeReference(value)) {
-            return Object.keys(value);
-        }
-        return undefined;
+        if (value === null || value === undefined)
+            return [];
+        return ownKeys(enumerableSource("for...in", value, node)).filter((key) => typeof key === "string");
     }
     evaluateForInStatement(node, labels) {
         const left = node.left;
@@ -664,43 +726,32 @@ class Frame {
             if (declared?.lexical)
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
             const right = yield* self.evaluateExpression(node.right);
-            const keys = self.enumerableKeys(right);
-            if (keys === undefined) {
-                throw new InterpreterRuntimeError("for...in requires a plain object, array, or tools reference. Use for...of for arrays/strings/Maps/Sets, or Object.keys(value) for a key list.", node);
-            }
+            const keys = self.enumerableKeys(right, node.right);
             if (left.type !== "Identifier" && left.type !== "VariableDeclaration") {
                 throw new InterpreterRuntimeError("Unsupported for...in binding.", left);
             }
             const assignmentName = left.type === "Identifier" ? left.name : undefined;
             for (const key of keys) {
                 const result = yield* Effect.gen(function* () {
-                    if (declared) {
+                    if (declared?.lexical) {
                         self.scopes.push();
-                        if (declared.lexical)
-                            self.predeclarePattern(declared.pattern, declared.mutable, left);
-                        yield* self.declarePattern(declared.pattern, key, declared.mutable, left, declared.lexical);
+                        self.predeclarePattern(declared.pattern, declared.mutable, left);
+                        yield* self.declarePattern(declared.pattern, key, declared.mutable, left, true);
+                    }
+                    else if (declared) {
+                        yield* self.assignPattern(declared.pattern, key, left);
                     }
                     else if (assignmentName) {
                         self.scopes.set(assignmentName, key, left);
                     }
                     return yield* self.evaluateStatement(node.body);
                 }).pipe(Effect.ensuring(Effect.sync(() => {
-                    if (declared)
+                    if (declared?.lexical)
                         self.scopes.pop();
                 })));
-                if (result.kind === "return") {
-                    return result;
-                }
-                if (result.kind === "break") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "continue") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    continue;
-                }
+                const exit = loopExit(result, labels);
+                if (exit !== undefined)
+                    return exit;
             }
             return { kind: "none" };
         }).pipe(Effect.ensuring(Effect.sync(() => {
@@ -781,8 +832,16 @@ class Frame {
                     throw new InterpreterRuntimeError("Unsupported variable declaration shape.", declaration);
                 }
                 const init = declaration.init;
-                const value = init ? yield* self.evaluateExpression(init) : undefined;
-                yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, kind !== "var");
+                // `var x` alone is a no-op: the binding was hoisted on function entry.
+                const id = declaration.id;
+                const evaluate = (init) => id.type === "Identifier" ? self.evaluateNamed(init, id.name) : self.evaluateExpression(init);
+                if (kind === "var") {
+                    if (init)
+                        yield* self.assignPattern(id, yield* evaluate(init), declaration);
+                    continue;
+                }
+                const value = init ? yield* evaluate(init) : undefined;
+                yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, true);
             }
         });
     }
@@ -798,23 +857,19 @@ class Frame {
                 return;
             }
             if (pattern.type === "AssignmentPattern") {
-                const resolved = value === undefined ? yield* self.evaluateExpression(pattern.right) : value;
+                const resolved = value === undefined ? yield* self.evaluateDefault(pattern) : value;
                 yield* self.declarePattern(pattern.left, resolved, mutable, node, initialize);
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (value === null || typeof value !== "object" || isRuntimeReference(value)) {
+                if (!(value instanceof ProgramObject)) {
                     throw new InterpreterRuntimeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern, "InvalidDataValue");
                 }
                 const consumed = new Set();
                 for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
-                        const rest = Object.create(null);
-                        for (const [key, item] of Object.entries(value)) {
-                            if (!consumed.has(key))
-                                rest[key] = item;
-                        }
-                        copyIteratorSymbols(value, rest, consumed);
+                        const rest = new ProgramObject();
+                        assign(rest, value, consumed);
                         yield* self.declarePattern(property.argument, rest, mutable, property, initialize);
                         continue;
                     }
@@ -842,30 +897,25 @@ class Frame {
                 return;
             }
             if (pattern.type === "AssignmentPattern") {
-                const resolved = value === undefined ? yield* self.evaluateExpression(pattern.right) : value;
+                const resolved = value === undefined ? yield* self.evaluateDefault(pattern) : value;
                 yield* self.assignPattern(pattern.left, resolved, node);
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (value === null || typeof value !== "object" || isRuntimeReference(value)) {
+                if (!(value instanceof ProgramObject)) {
                     throw new InterpreterRuntimeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern, "InvalidDataValue");
                 }
-                const source = value;
                 const consumed = new Set();
                 for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
-                        const rest = Object.create(null);
-                        for (const [key, item] of Object.entries(source)) {
-                            if (!consumed.has(key))
-                                rest[key] = item;
-                        }
-                        copyIteratorSymbols(source, rest, consumed);
+                        const rest = new ProgramObject();
+                        assign(rest, value, 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.destructuringPropertyValue(source, key), property);
+                    yield* self.assignPattern(property.value, self.destructuringPropertyValue(value, key), property);
                 }
                 return;
             }
@@ -875,6 +925,11 @@ class Frame {
             throw new InterpreterRuntimeError(`Unsupported assignment pattern '${pattern.type}'.`, node);
         });
     }
+    evaluateDefault(pattern) {
+        return pattern.left.type === "Identifier"
+            ? this.evaluateNamed(pattern.right, pattern.left.name)
+            : this.evaluateExpression(pattern.right);
+    }
     destructureArrayPattern(pattern, value, consume) {
         const self = this;
         return Effect.gen(function* () {
@@ -887,7 +942,7 @@ class Frame {
                 if (done) {
                     if (element === null)
                         continue;
-                    yield* consume(element.type === "RestElement" ? element.argument : element, element.type === "RestElement" ? [] : undefined, element);
+                    yield* consume(element.type === "RestElement" ? element.argument : element, element.type === "RestElement" ? new ProgramArray() : undefined, element);
                     if (element.type === "RestElement")
                         return;
                     continue;
@@ -906,7 +961,7 @@ class Frame {
                         if (!done)
                             rest.push(next.value);
                     }
-                    yield* consume(element.argument, rest, element);
+                    yield* consume(element.argument, new ProgramArray(rest), element);
                     return;
                 }
                 const consumed = consume(element, step.done ? undefined : step.value, pattern);
@@ -931,14 +986,10 @@ class Frame {
         throw unsupportedSyntax(keyNode.type, keyNode);
     }
     destructuringPropertyValue(source, key) {
-        if (!Array.isArray(source))
-            return Reflect.get(source, key);
-        if (key === "length")
-            return source.length;
-        if (typeof key === "number")
-            return source[key];
-        if (Object.hasOwn(source, key))
-            return Reflect.get(source, key);
+        if (!(source instanceof ProgramArray))
+            return get(source, key);
+        if (has(source, key))
+            return get(source, key);
         if (typeof key === "string" && arrayMethods.has(key))
             return new IntrinsicReference(source, key);
         return undefined;
@@ -1013,7 +1064,7 @@ class Frame {
                 // unsupported syntax. Built-ins like Number are real constructors in JS, so do not claim
                 // otherwise; say `new` is unsupported for them and point at the plain call.
                 const name = calleeDescription(node.callee);
-                const message = callee instanceof CodeModeFunction
+                const message = callee instanceof ProgramFunction
                     ? `${name} cannot be constructed: user-defined constructors and classes are not supported. Call it as a function that returns a plain object instead.`
                     : callee instanceof HostFunction
                         ? `new ${name}(...) is not supported; call ${name}(...) without new instead.`
@@ -1043,6 +1094,9 @@ class Frame {
             return lhs === rhs;
         if (operator === "!==")
             return lhs !== rhs;
+        if (operator === "in" && rhs instanceof ProgramObject && !containsOpaqueReference(lhs)) {
+            return has(rhs, lhs !== null && typeof lhs === "object" ? coerceToString(lhs) : lhs);
+        }
         if (containsOpaqueReference(lhs) || containsOpaqueReference(rhs)) {
             throw new InterpreterRuntimeError("Binary operators require data values.", node, "InvalidDataValue");
         }
@@ -1095,11 +1149,10 @@ class Frame {
             case ">>>":
                 return l >>> r;
             case "in":
-                if (rhs === null || typeof rhs !== "object") {
+                if (!(rhs instanceof ProgramObject)) {
                     throw new InterpreterRuntimeError("The 'in' operator requires a data object on the right-hand side.", node);
                 }
-                // Never expose properties inherited from host prototypes.
-                return Object.hasOwn(rhs, coerceOperand(lhs));
+                return has(rhs, coerceOperand(lhs));
             default:
                 throw new InterpreterRuntimeError(`Unsupported binary operator '${operator}'.`, node);
         }
@@ -1178,7 +1231,7 @@ class Frame {
                     const next = toProgram(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
                     return self.scopes.set(name, next, left);
                 }
-                const rightValue = yield* self.evaluateExpression(node.right);
+                const rightValue = yield* self.evaluateNamed(node.right, name);
                 return self.scopes.set(name, rightValue, left);
             }
             if (left.type === "MemberExpression") {
@@ -1201,7 +1254,7 @@ class Frame {
                 const current = self.scopes.get(name, left);
                 if (!shouldAssign(current))
                     return current;
-                const rightValue = yield* self.evaluateExpression(node.right);
+                const rightValue = yield* self.evaluateNamed(node.right, name);
                 return self.scopes.set(name, rightValue, left);
             });
         }
@@ -1275,7 +1328,7 @@ class Frame {
                 }
                 return yield* self.createToolCallPromise(callable.path, args);
             }
-            if (callable instanceof CodeModeFunction) {
+            if (callable instanceof ProgramFunction) {
                 return yield* self.invokeFunction(callable, args);
             }
             if (callable instanceof GeneratorMethodReference) {
@@ -1334,12 +1387,14 @@ class Frame {
             }
             for (const [index, parameter] of fn.parameters.entries()) {
                 if (parameter.type === "RestElement") {
-                    yield* invocation.declarePattern(parameter.argument, args.slice(index), true, parameter, true);
+                    yield* invocation.declarePattern(parameter.argument, new ProgramArray(args.slice(index)), true, parameter, true);
                     break;
                 }
                 yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
             }
             if (fn.body.type === "BlockStatement") {
+                invocation.scopes.push();
+                invocation.hoistVars(fn.body.body, paramScope);
                 const result = yield* invocation.evaluateStatement(fn.body);
                 return result.kind === "return" ? result.value : undefined;
             }
@@ -1349,12 +1404,7 @@ class Frame {
             return Effect.succeed(this.createGenerator(invocation, run, fn.async));
         if (!fn.async)
             return run;
-        // The initial yield assigns the promise before the body can self-resolve.
-        const box = {};
-        return Effect.map(this.createPromise(Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, box))), (promise) => {
-            box.promise = promise;
-            return promise;
-        });
+        return this.runtime.promises.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, self)));
     }
     createGenerator(invocation, run, asynchronous) {
         const state = { started: false, completed: false, draining: false, pending: [], pendingIndex: 0 };
@@ -1379,13 +1429,13 @@ class Frame {
             if (state.completed) {
                 if (kind === "throw")
                     return Effect.fail(new ProgramThrow(value));
-                return Effect.succeed({ value: kind === "return" ? value : undefined, done: true });
+                return Effect.succeed(record({ value: kind === "return" ? value : undefined, done: true }));
             }
             if (!state.started && kind !== "next") {
                 state.completed = true;
                 if (kind === "throw")
                     return Effect.fail(new ProgramThrow(value));
-                return Effect.succeed({ value, done: true });
+                return Effect.succeed(record({ value, done: true }));
             }
             state.pending.push(request);
             if (state.available) {
@@ -1405,7 +1455,7 @@ class Frame {
                     const active = state.active;
                     state.active = undefined;
                     if (active) {
-                        Deferred.doneUnsafe(active.response, Exit.isSuccess(exit) ? Exit.succeed({ value: exit.value, done: true }) : exit);
+                        Deferred.doneUnsafe(active.response, Exit.isSuccess(exit) ? Exit.succeed(record({ value: exit.value, done: true })) : exit);
                     }
                     yield* invocation.completeGeneratorRequests(state, asynchronous);
                     state.completed = true;
@@ -1429,10 +1479,10 @@ class Frame {
                 }
                 if (asynchronous && pending.kind === "return") {
                     const resolved = yield* Effect.exit(self.awaitValue(pending.value));
-                    Deferred.doneUnsafe(pending.response, Exit.isSuccess(resolved) ? Exit.succeed({ value: resolved.value, done: true }) : resolved);
+                    Deferred.doneUnsafe(pending.response, Exit.isSuccess(resolved) ? Exit.succeed(record({ value: resolved.value, done: true })) : resolved);
                     continue;
                 }
-                Deferred.doneUnsafe(pending.response, Exit.succeed({ value: pending.kind === "return" ? pending.value : undefined, done: true }));
+                Deferred.doneUnsafe(pending.response, Exit.succeed(record({ value: pending.kind === "return" ? pending.value : undefined, done: true })));
             }
         });
     }
@@ -1473,7 +1523,7 @@ class Frame {
         const state = this.generatorState;
         if (!state?.active)
             throw new InterpreterRuntimeError("Generator has no active request.", node);
-        Deferred.doneUnsafe(state.active.response, Exit.succeed({ value, done: false }));
+        Deferred.doneUnsafe(state.active.response, Exit.succeed(record({ value, done: false })));
         state.active = undefined;
         return Effect.flatMap(this.takeGeneratorRequest(state), (request) => {
             state.active = request;
@@ -1489,7 +1539,7 @@ class Frame {
     delegateYield(value, node) {
         const self = this;
         return Effect.gen(function* () {
-            if (Array.isArray(value) ||
+            if (value instanceof ProgramArray ||
                 typeof value === "string" ||
                 value instanceof Values.Map ||
                 value instanceof Values.Set ||
@@ -1526,7 +1576,7 @@ class Frame {
                     ? iterator.next
                     : iterator.iterator instanceof CodeModeGenerator
                         ? new GeneratorMethodReference(iterator.iterator, kind)
-                        : iterator.iterator[kind];
+                        : get(iterator.iterator, kind);
                 if (method === undefined || method === null) {
                     if (kind === "return")
                         return yield* Effect.fail(new GeneratorReturn(input));
@@ -1535,10 +1585,10 @@ class Frame {
                 }
                 const called = yield* self.invokeCallable(self.requireIteratorMethod(method, `Iterator ${kind}`, node), [input], node);
                 const result = self.requireIteratorObject(iterator.asynchronous ? yield* self.awaitValue(called) : called, `Iterator ${kind}() result`, node);
-                const done = Boolean(result.done);
+                const done = Boolean(get(result, "done"));
                 const resultValue = self.generatorAsync && !iterator.asynchronous
-                    ? yield* self.awaitAsyncFromSyncValue(iterator, result.value, node, kind !== "return" && !done)
-                    : result.value;
+                    ? yield* self.awaitAsyncFromSyncValue(iterator, get(result, "value"), node, kind !== "return" && !done)
+                    : get(result, "value");
                 if (done) {
                     if (kind === "return")
                         return yield* Effect.fail(new GeneratorReturn(resultValue));
@@ -1560,20 +1610,15 @@ class Frame {
         });
     }
     evaluateObjectExpression(node) {
-        const objectValue = Object.create(null);
+        const objectValue = new ProgramObject();
         const self = this;
         return Effect.gen(function* () {
             for (const property of node.properties) {
                 if (property.type === "SpreadElement") {
                     const spread = yield* self.evaluateExpression(property.argument);
-                    if (spread === null || spread === undefined || Values.isValue(spread))
+                    if (spread === null || spread === undefined)
                         continue;
-                    if (typeof spread !== "object" || Array.isArray(spread) || isRuntimeReference(spread)) {
-                        throw new InterpreterRuntimeError(`Object spread requires a data object, received ${describeValue(spread)}.`, property, "InvalidDataValue");
-                    }
-                    for (const [key, value] of Object.entries(spread))
-                        objectValue[key] = value;
-                    copyIteratorSymbols(spread, objectValue);
+                    assign(objectValue, enumerableSource("Object spread", spread, property));
                     continue;
                 }
                 if (property.kind !== "init") {
@@ -1593,7 +1638,12 @@ class Frame {
                 else {
                     throw new InterpreterRuntimeError("Unsupported object property key shape.", keyNode);
                 }
-                Reflect.set(objectValue, key, yield* self.evaluateExpression(property.value));
+                const name = key === IteratorSymbol
+                    ? "[Symbol.iterator]"
+                    : key === AsyncIteratorSymbol
+                        ? "[Symbol.asyncIterator]"
+                        : String(key);
+                set(objectValue, key, yield* self.evaluateNamed(property.value, name));
             }
             return objectValue;
         });
@@ -1624,7 +1674,7 @@ class Frame {
                     values.push(yield* self.evaluateExpression(element));
                 }
             }
-            return values;
+            return new ProgramArray(values);
         });
     }
     evaluateTemplateLiteral(node) {
@@ -1686,6 +1736,14 @@ class Frame {
                 // Unknown static members read as undefined so feature detection works like native JS.
                 return new ComputedValue(objectValue.member(key, propertyNode));
             }
+            // Values have no prototype chain, so `.constructor` resolves to the owning built-in directly.
+            if (operation === "read" &&
+                key === "constructor" &&
+                !(objectValue instanceof ProgramObject && has(objectValue, key))) {
+                const name = constructorName(objectValue);
+                if (name !== undefined)
+                    return new ComputedValue(self.runtime.builtins.get(name));
+            }
             if (typeof objectValue === "string") {
                 if (key === "length")
                     return new ComputedValue(objectValue.length);
@@ -1765,28 +1823,16 @@ class Frame {
                 }
                 return new ComputedValue(undefined);
             }
+            if (objectValue instanceof ProgramObject)
+                return { target: objectValue, key };
             if (isRuntimeReference(objectValue)) {
                 throw new InterpreterRuntimeError(`Cannot read properties of ${describeValue(objectValue)}; only data values expose properties.`, objectNode, "InvalidDataValue");
             }
-            if (typeof objectValue !== "object" || objectValue === null) {
-                throw new InterpreterRuntimeError("Cannot access a property on a non-object value.", objectNode);
-            }
-            if (Array.isArray(objectValue)) {
-                if (operation === "delete")
-                    return { target: objectValue, key };
-                const index = typeof key === "symbol" ? undefined : parseArrayIndex(key);
-                if (key !== "length" && !(typeof key === "string" && arrayMethods.has(key)) && index === undefined) {
-                    if (typeof key === "string" && Object.hasOwn(objectValue, key)) {
-                        return new ComputedValue(objectValue[key]);
-                    }
-                    return new ComputedValue(undefined);
-                }
-                return { target: objectValue, key: index ?? key };
-            }
-            return { target: objectValue, key };
+            throw new InterpreterRuntimeError("Cannot access a property on a non-object value.", objectNode);
         });
     }
     readMember(node) {
+        const self = this;
         return Effect.map(this.getMemberReference(node), (reference) => {
             if (reference === OptionalShortCircuit)
                 return OptionalShortCircuit;
@@ -1794,19 +1840,15 @@ class Frame {
                 return reference.value;
             if (reference === undefined || isOpaqueMemberReference(reference))
                 return reference;
-            if (Array.isArray(reference.target)) {
-                if (reference.key === "length")
-                    return reference.target.length;
-                if (typeof reference.key === "string")
-                    return new IntrinsicReference(reference.target, reference.key);
-                return Reflect.get(reference.target, reference.key);
-            }
-            if (reference.target instanceof Values.RegExp)
-                return reference.target.lastIndex;
-            if (reference.target instanceof Values.URL) {
-                return Reflect.get(reference.target.url, reference.key);
-            }
-            return Reflect.get(reference.target, reference.key);
+            const value = self.readReferenceValue(reference, reference.key);
+            if (value === undefined &&
+                reference.target instanceof ProgramArray &&
+                typeof reference.key === "string" &&
+                arrayMethods.has(reference.key) &&
+                !has(reference.target, reference.key)) {
+                return new IntrinsicReference(reference.target, reference.key);
+            }
+            return value;
         });
     }
     writeMember(node, value) {
@@ -1829,27 +1871,20 @@ class Frame {
             if (reference.target instanceof Values.RegExp) {
                 return Reflect.deleteProperty(reference.target.regex, reference.key);
             }
-            return Reflect.deleteProperty(reference.target, reference.key);
+            return remove(reference.target, reference.key);
         });
     }
     // Resolve side-effecting object and key expressions exactly once.
     modifyMember(node, compute) {
         const self = this;
         return Effect.gen(function* () {
-            const reference = yield* self.getMemberReference(node);
+            const reference = yield* self.getMemberReference(node, "write");
             if (reference === OptionalShortCircuit ||
                 reference instanceof ComputedValue ||
                 reference === undefined ||
                 isOpaqueMemberReference(reference)) {
                 throw new InterpreterRuntimeError("Only data fields may be assigned.", node);
             }
-            if (Array.isArray(reference.target)) {
-                if (reference.key === "length")
-                    throw new InterpreterRuntimeError("Array length cannot be assigned.", node);
-                if (typeof reference.key === "string" && arrayMethods.has(reference.key)) {
-                    throw new InterpreterRuntimeError("Array methods cannot be assigned.", node);
-                }
-            }
             const key = reference.key;
             const { write, next, result } = yield* compute(self.readReferenceValue(reference, key));
             if (write)
@@ -1863,18 +1898,9 @@ class Frame {
         }
         if (reference.target instanceof Values.RegExp)
             return reference.target.lastIndex;
-        return Reflect.get(reference.target, key);
+        return get(reference.target, key);
     }
     assignToReference(reference, key, next, node) {
-        if (Array.isArray(reference.target)) {
-            const target = reference.target;
-            if (typeof key !== "number" || parseArrayIndex(key) === undefined) {
-                throw new InterpreterRuntimeError("Array assignment index must be a valid array index.", node, "InvalidDataValue");
-            }
-            rejectCircularInsertion(target, next, "Array assignment result", node);
-            target[key] = next;
-            return;
-        }
         if (reference.target instanceof Values.URL) {
             const property = key;
             if (!urlWritableProperties.has(property)) {
@@ -1896,8 +1922,12 @@ class Frame {
             return;
         }
         const target = reference.target;
-        rejectCircularInsertion(target, next, "Object assignment result", node);
-        Reflect.set(target, key, next);
+        rejectCircularInsertion(target, next, target instanceof ProgramArray ? "Array assignment result" : "Object assignment result", node);
+        if (set(target, key, next))
+            return;
+        if (target instanceof ProgramArray)
+            throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
+        throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node).as("TypeError");
     }
     toPropertyKey(value, node) {
         if (typeof value === "string" || typeof value === "number") {