@opencode/codemode 0.0.0-beta-19507 → 0.0.0-dev-19276

package/dist/interpreter/runtime.js

@@ -1,223 +1,200 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
-import { ToolRuntimeError, toProgram } from "../data.js";
-import { ToolReference } from "../tool-runtime.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";
+import { isBlockedMember, ToolReference, ToolRuntimeError } from "../tool-runtime.js";
+import { AsyncIteratorSymbol, asNode, CodeModeFunction, CodeModeGenerator, CoercionFunction, ComputedValue, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, GeneratorMethodReference, GeneratorReturn, getArray, getBoolean, getNode, getOptionalNode, getString, IntrinsicReference, InterpreterRuntimeError, isRecord, IteratorSymbol, IteratorSymbols, JsonMethodReference, OptionalShortCircuit, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, PromiseNamespace, ProgramThrow, SearchFunction, SymbolNamespace, unsupportedSyntax, UriFunction, } from "./model.js";
+import { caughtErrorValue, constructAggregateErrorValue, constructErrorValue } from "./errors.js";
+import { arrayStatics, invokeArrayFrom, invokeGlobalMethod, invokeGroupBy, invokeIntrinsic, } from "./methods.js";
+import { preserveConsumerError } from "./iterator.js";
+import { constructPromise, invokePromiseInstanceMethod, invokePromiseMethod, PromiseRuntime, resolvePromise, resolvePromiseValue, } from "./promises.js";
+import { containsOpaqueReference, isRuntimeReference, rejectCircularInsertion, typeofValue } from "./references.js";
 import { ScopeStack } from "./scope.js";
-import { arrayMethods, mapMethods, setMethods } from "../stdlib/collections.js";
-import { dateMethods } from "../stdlib/date.js";
-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 { enumerableSource } from "../stdlib/object.js";
-import { coerceToNumber, coerceToString, compoundOperators, errorBrandName } from "../stdlib/value.js";
-import { Values } from "../values.js";
-// 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;
+import { arrayMethods, mapMethods, mapStatics, setMethods } from "../stdlib/collections.js";
+import { consoleMethods, formatConsoleMessage } from "../stdlib/console.js";
+import { dateMethods, dateStatics } from "../stdlib/date.js";
+import { invokeJsonMethod, jsonStatics } from "../stdlib/json.js";
+import { invokeMathSumPrecise, mathConstants, mathMethods } from "../stdlib/math.js";
+import { numberConstants, numberMethods, numberStatics } from "../stdlib/number.js";
+import { invokeObjectFromEntries, objectMethodsPreservingIdentity, objectStatics } from "../stdlib/object.js";
+import { promiseStatics } from "../stdlib/promise.js";
+import { escapeRegexHint, regexpMethods, regexpProperties, regexpStatics, regexFailureReason, } from "../stdlib/regexp.js";
+import { stringMethods, stringStatics } from "../stdlib/string.js";
+import { urlMethods, urlProperties, urlSearchParamsMethods, urlStatics, urlWritableProperties, invokeUriFunction, uriArgument, urlArgument, } from "../stdlib/url.js";
+import { boundedData, coerceToNumber, coerceToString, compoundOperators, errorBrandName, errorConstructors, invokeCoercion, valueConstructors, } from "../stdlib/value.js";
+import { isCodeModeValue, CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
+const globalStaticMembers = {
+    Object: objectStatics,
+    Math: mathMethods,
+    Array: arrayStatics,
+    console: consoleMethods,
+    Date: dateStatics,
+    RegExp: regexpStatics,
+    Map: mapStatics,
+    URL: urlStatics,
+};
+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;
 };
 const calleeDescription = (callee) => {
-    if (callee?.type === "Identifier")
-        return callee.name;
-    if (callee?.type === "MemberExpression") {
-        const object = callee.object;
-        const property = callee.property;
-        const key = !callee.computed && property.type === "Identifier"
-            ? property.name
+    if (callee.type === "Identifier")
+        return getString(callee, "name");
+    if (callee.type === "MemberExpression") {
+        const object = getNode(callee, "object");
+        const property = getNode(callee, "property");
+        const key = callee.computed !== true && property.type === "Identifier"
+            ? getString(property, "name")
             : property.type === "Literal" && typeof property.value === "string"
                 ? property.value
                 : undefined;
         if (object.type === "Identifier" && key !== undefined)
-            return `${object.name}.${key}`;
+            return `${getString(object, "name")}.${key}`;
     }
     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);
+    if (rhs instanceof ErrorConstructorReference) {
+        const brand = errorBrandName(lhs);
+        return brand !== undefined && (rhs.name === "Error" || brand === rhs.name);
+    }
+    if (rhs instanceof GlobalNamespace) {
+        switch (rhs.name) {
+            case "Date":
+                return lhs instanceof CodeModeDate;
+            case "RegExp":
+                return lhs instanceof CodeModeRegExp;
+            case "Map":
+                return lhs instanceof CodeModeMap;
+            case "Set":
+                return lhs instanceof CodeModeSet;
+            case "URL":
+                return lhs instanceof CodeModeURL;
+            case "URLSearchParams":
+                return lhs instanceof CodeModeURLSearchParams;
+            case "Array":
+                return Array.isArray(lhs);
+            case "Object":
+                return lhs !== null && (typeof lhs === "object" || typeofValue(lhs) === "function");
+        }
+    }
+    if (rhs instanceof PromiseNamespace)
+        return lhs instanceof CodeModePromise;
+    if (rhs instanceof CoercionFunction && (rhs.name === "Number" || rhs.name === "String" || rhs.name === "Boolean")) {
+        return false;
+    }
     throw new InterpreterRuntimeError("The right-hand side of 'instanceof' must be a supported constructor: Error (or a specific error type like TypeError), Date, RegExp, Map, Set, URL, URLSearchParams, Array, Object, or Promise.", node);
 };
 const collectPatternNames = (pattern, out = []) => {
     switch (pattern.type) {
         case "Identifier":
-            out.push(pattern.name);
+            out.push(getString(pattern, "name"));
             break;
         case "AssignmentPattern":
-            collectPatternNames(pattern.left, out);
+            collectPatternNames(getNode(pattern, "left"), out);
             break;
         case "RestElement":
-            collectPatternNames(pattern.argument, out);
+            collectPatternNames(getNode(pattern, "argument"), out);
             break;
         case "ArrayPattern":
-            for (const element of pattern.elements) {
+            for (const element of getArray(pattern, "elements")) {
                 if (element !== null)
-                    collectPatternNames(element, out);
+                    collectPatternNames(asNode(element, "elements"), out);
             }
             break;
         case "ObjectPattern":
-            for (const prop of pattern.properties) {
-                collectPatternNames(prop.type === "RestElement" ? prop.argument : prop.value, out);
+            for (const property of getArray(pattern, "properties")) {
+                const prop = asNode(property, "properties");
+                collectPatternNames(prop.type === "RestElement" ? getNode(prop, "argument") : getNode(prop, "value"), out);
             }
             break;
     }
     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;
-    const declaration = left.declarations.length === 1 ? left.declarations[0] : undefined;
-    if (declaration === undefined) {
+    const declarations = getArray(left, "declarations");
+    if (declarations.length !== 1) {
         throw new InterpreterRuntimeError(`${statement} supports one declared binding.`, left);
     }
-    const kind = left.kind;
+    const kind = getString(left, "kind");
     return {
-        pattern: declaration.id,
+        pattern: getNode(asNode(declarations[0], "declarations[0]"), "id"),
         mutable: kind !== "const",
         lexical: kind !== "var",
     };
 };
 const isOpaqueMemberReference = (value) => value instanceof ToolReference ||
+    value instanceof PromiseMethodReference ||
     value instanceof PromiseInstanceMethodReference ||
     value instanceof IntrinsicReference ||
+    value instanceof GlobalMethodReference ||
+    value instanceof JsonMethodReference ||
     value instanceof GeneratorMethodReference;
-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 {
+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" };
+export class Interpreter {
+    scopes;
     executeTool;
-    search;
+    invokeSearch;
     toolKeys;
-    promises;
     logs;
-    runner;
-    /** Built-in globals by name, unaffected by program shadowing. */
-    builtins;
-    root;
-    constructor(executeTool, search, toolKeys, promises, logs = [], extraGlobals = () => []) {
+    promises;
+    generatorState;
+    generatorAsync = false;
+    runner = {
+        invokeFunction: (fn, args) => this.invokeFunction(fn, args),
+        invokeCallable: (callable, args, node) => this.invokeCallable(callable, args, node),
+        settlePromise: (promise) => this.settlePromise(promise),
+        syncIterator: (value, node) => this.syncIterator(value, node),
+    };
+    constructor(executeTool, invokeSearch, toolKeys, promises, logs = []) {
+        const globalScope = new Map();
+        this.scopes = new ScopeStack([globalScope]);
         this.executeTool = executeTool;
-        this.search = search;
+        this.invokeSearch = invokeSearch;
         this.toolKeys = toolKeys;
-        this.promises = promises;
         this.logs = logs;
-        const globalScope = new Map();
-        // 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]));
-        this.runner = {
-            invokeFunction: (fn, args) => this.root.invokeFunction(fn, args),
-            invokeCallable: (callable, args, node) => this.root.invokeCallable(callable, args, node),
-            settlePromise: (promise) => this.root.settlePromise(promise),
-            syncIterator: (value, node) => this.root.syncIterator(value, node),
-        };
-        this.builtins = new Map([...globals(this), ...extraGlobals(this)]);
-        for (const [name, value] of this.builtins)
-            globalScope.set(name, { mutable: false, value });
-    }
-    run(program) {
-        return this.root.run(program);
-    }
-}
-/** One activation: the top-level program or a single function call, evaluating against its own scope chain. */
-class Frame {
-    runtime;
-    scopes;
-    generatorState;
-    generatorAsync = false;
-    constructor(runtime, scopes) {
-        this.runtime = runtime;
-        this.scopes = scopes;
+        this.promises = promises;
+        globalScope.set("tools", { mutable: false, value: new ToolReference([]) });
+        globalScope.set("search", { mutable: false, value: new SearchFunction() });
+        globalScope.set("Promise", { mutable: false, value: new PromiseNamespace() });
+        globalScope.set("Symbol", { mutable: false, value: new SymbolNamespace() });
+        globalScope.set("undefined", { mutable: false, value: undefined });
+        globalScope.set("Object", { mutable: false, value: new GlobalNamespace("Object") });
+        globalScope.set("Math", { mutable: false, value: new GlobalNamespace("Math") });
+        globalScope.set("JSON", { mutable: false, value: new GlobalNamespace("JSON") });
+        globalScope.set("Number", { mutable: false, value: new CoercionFunction("Number") });
+        globalScope.set("String", { mutable: false, value: new CoercionFunction("String") });
+        globalScope.set("Boolean", { mutable: false, value: new CoercionFunction("Boolean") });
+        globalScope.set("Array", { mutable: false, value: new GlobalNamespace("Array") });
+        globalScope.set("console", { mutable: false, value: new GlobalNamespace("console") });
+        globalScope.set("parseInt", { mutable: false, value: new CoercionFunction("parseInt") });
+        globalScope.set("parseFloat", { mutable: false, value: new CoercionFunction("parseFloat") });
+        globalScope.set("isFinite", { mutable: false, value: new CoercionFunction("isFinite") });
+        globalScope.set("isNaN", { mutable: false, value: new CoercionFunction("isNaN") });
+        globalScope.set("Date", { mutable: false, value: new GlobalNamespace("Date") });
+        globalScope.set("RegExp", { mutable: false, value: new GlobalNamespace("RegExp") });
+        globalScope.set("Map", { mutable: false, value: new GlobalNamespace("Map") });
+        globalScope.set("Set", { mutable: false, value: new GlobalNamespace("Set") });
+        globalScope.set("URL", { mutable: false, value: new GlobalNamespace("URL") });
+        globalScope.set("URLSearchParams", { mutable: false, value: new GlobalNamespace("URLSearchParams") });
+        globalScope.set("encodeURI", { mutable: false, value: new UriFunction("encodeURI") });
+        globalScope.set("encodeURIComponent", { mutable: false, value: new UriFunction("encodeURIComponent") });
+        globalScope.set("decodeURI", { mutable: false, value: new UriFunction("decodeURI") });
+        globalScope.set("decodeURIComponent", { mutable: false, value: new UriFunction("decodeURIComponent") });
+        for (const name of errorConstructors) {
+            globalScope.set(name, { mutable: false, value: new ErrorConstructorReference(name) });
+        }
+        globalScope.set("NaN", { mutable: false, value: NaN });
+        globalScope.set("Infinity", { mutable: false, value: Infinity });
     }
     run(program) {
         const self = this;
@@ -226,11 +203,10 @@ 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") {
-                    value = yield* self.evaluateExpression(statement.expression);
+                    value = yield* self.evaluateExpression(getNode(statement, "expression"));
                     break;
                 }
                 const result = yield* self.evaluateStatement(statement);
@@ -243,20 +219,20 @@ class Frame {
                 }
             }
             // The implicit async body adopts returned promises before copy-out.
-            value = yield* resolvePromiseValue(self.runtime.runner, value, program);
+            value = yield* resolvePromiseValue(self.runner, value, program);
             return value;
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
     // Fork at the call site so admission and hooks occur when the call is made.
     createToolCallPromise(path, args) {
-        return this.createPromise(Effect.suspend(() => this.runtime.executeTool(path, args)));
+        return this.createPromise(Effect.suspend(() => this.executeTool(path, args)));
     }
     createPromise(effect) {
-        return this.runtime.promises.create(effect);
+        return this.promises.create(effect);
     }
     // Fiber exits make settlement idempotent; yielding prevents inline continuation.
     settlePromise(promise) {
-        const promises = this.runtime.promises;
+        const promises = this.promises;
         return Effect.suspend(() => {
             promises.markObserved(promise);
             return Effect.flatMap(promises.await(promise), (exit) => Effect.andThen(Effect.yieldNow, exit));
@@ -265,11 +241,11 @@ class Frame {
     evaluateStatement(node) {
         switch (node.type) {
             case "ExpressionStatement":
-                return Effect.as(this.evaluateExpression(node.expression), { kind: "none" });
+                return Effect.as(this.evaluateExpression(getNode(node, "expression")), { kind: "none" });
             case "VariableDeclaration":
                 return Effect.map(this.evaluateVariableDeclaration(node), () => ({ kind: "none" }));
             case "ReturnStatement": {
-                const argumentNode = node.argument;
+                const argumentNode = getOptionalNode(node, "argument");
                 return argumentNode
                     ? Effect.map(this.evaluateExpression(argumentNode), (value) => ({ kind: "return", value }))
                     : Effect.succeed({ kind: "return", value: undefined });
@@ -312,10 +288,11 @@ class Frame {
         this.scopes.push();
         const self = this;
         return Effect.gen(function* () {
-            const body = node.body;
+            const body = getArray(node, "body");
             self.predeclareLexical(body);
             self.hoistFunctions(body);
-            for (const statement of body) {
+            for (const statementValue of body) {
+                const statement = asNode(statementValue, "body");
                 const result = yield* self.evaluateStatement(statement);
                 if (result.kind !== "none") {
                     return result;
@@ -324,45 +301,28 @@ class Frame {
             return { kind: "none" };
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
-    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);
+    createFunction(node) {
+        return new CodeModeFunction(getArray(node, "params").map((parameter, index) => asNode(parameter, `params[${index}]`)), getNode(node, "body"), this.scopes.capture(), node.async === true, node.generator === true);
     }
     hoistFunctions(statements) {
-        for (const node of statements) {
-            if (node.type !== "FunctionDeclaration")
+        for (const statementValue of statements) {
+            if (!isRecord(statementValue) || statementValue.type !== "FunctionDeclaration")
                 continue;
-            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 });
+            const node = statementValue;
+            this.scopes.declare(getString(getNode(node, "id"), "name"), this.createFunction(node), true, node);
         }
     }
     predeclareLexical(statements) {
-        for (const statement of statements) {
-            if (statement.type !== "VariableDeclaration")
+        for (const statementValue of statements) {
+            if (!isRecord(statementValue) || statementValue.type !== "VariableDeclaration")
                 continue;
-            const kind = statement.kind;
+            const statement = statementValue;
+            const kind = getString(statement, "kind");
             if (kind === "var")
                 continue;
-            for (const declaration of statement.declarations) {
-                for (const name of collectPatternNames(declaration.id)) {
+            for (const declarationValue of getArray(statement, "declarations")) {
+                const declaration = asNode(declarationValue, "declarations");
+                for (const name of collectPatternNames(getNode(declaration, "id"))) {
                     this.scopes.reserve(name, kind !== "const", declaration);
                 }
             }
@@ -373,29 +333,30 @@ class Frame {
             this.scopes.reserve(name, mutable, node);
     }
     evaluateIfStatement(node) {
-        return Effect.flatMap(this.evaluateExpression(node.test), (test) => test
-            ? this.evaluateStatement(node.consequent)
-            : node.alternate
-                ? this.evaluateStatement(node.alternate)
+        const testNode = getNode(node, "test");
+        const consequentNode = getNode(node, "consequent");
+        const alternateNode = getOptionalNode(node, "alternate");
+        return Effect.flatMap(this.evaluateExpression(testNode), (test) => test
+            ? this.evaluateStatement(consequentNode)
+            : alternateNode
+                ? this.evaluateStatement(alternateNode)
                 : Effect.succeed({ kind: "none" }));
     }
     evaluateSwitchStatement(node) {
         const self = this;
         return Effect.gen(function* () {
-            const discriminant = yield* self.evaluateExpression(node.discriminant);
+            const discriminant = yield* self.evaluateExpression(getNode(node, "discriminant"));
             if (containsOpaqueReference(discriminant)) {
                 throw new InterpreterRuntimeError("Switch discriminants must be data values.", node, "InvalidDataValue");
             }
             self.scopes.push();
             return yield* Effect.gen(function* () {
-                const cases = node.cases;
-                const statements = cases.flatMap((branch) => branch.consequent);
-                self.predeclareLexical(statements);
-                self.hoistFunctions(statements);
+                const cases = getArray(node, "cases").map((value, index) => asNode(value, `cases[${index}]`));
+                self.predeclareLexical(cases.flatMap((branch) => getArray(branch, "consequent")));
                 let defaultIndex;
                 let selected;
                 for (const [index, branch] of cases.entries()) {
-                    const test = branch.test;
+                    const test = getOptionalNode(branch, "test");
                     if (!test) {
                         defaultIndex = index;
                         continue;
@@ -413,8 +374,8 @@ class Frame {
                 if (start === undefined)
                     return { kind: "none" };
                 for (let index = start; index < cases.length; index += 1) {
-                    for (const statement of cases[index].consequent) {
-                        const result = yield* self.evaluateStatement(statement);
+                    for (const statementValue of getArray(cases[index], "consequent")) {
+                        const result = yield* self.evaluateStatement(asNode(statementValue, "consequent"));
                         if (result.kind === "break") {
                             if (result.label === undefined)
                                 return { kind: "none" };
@@ -429,24 +390,50 @@ class Frame {
         });
     }
     evaluateWhileStatement(node, labels) {
+        const testNode = getNode(node, "test");
+        const bodyNode = getNode(node, "body");
         const self = this;
         return Effect.gen(function* () {
-            while (yield* self.evaluateExpression(node.test)) {
-                const exit = loopExit(yield* self.evaluateStatement(node.body), labels);
-                if (exit !== undefined)
-                    return exit;
+            while (yield* self.evaluateExpression(testNode)) {
+                const result = yield* self.evaluateStatement(bodyNode);
+                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;
+                }
             }
             return { kind: "none" };
         });
     }
     evaluateDoWhileStatement(node, labels) {
+        const bodyNode = getNode(node, "body");
+        const testNode = getNode(node, "test");
         const self = this;
         return Effect.gen(function* () {
             do {
-                const exit = loopExit(yield* self.evaluateStatement(node.body), labels);
-                if (exit !== undefined)
-                    return exit;
-            } while (yield* self.evaluateExpression(node.test));
+                const result = yield* self.evaluateStatement(bodyNode);
+                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;
+                }
+            } while (yield* self.evaluateExpression(testNode));
             return { kind: "none" };
         });
     }
@@ -454,10 +441,11 @@ class Frame {
         this.scopes.push();
         const self = this;
         return Effect.gen(function* () {
-            const initNode = node.init;
-            const testNode = node.test;
-            const updateNode = node.update;
-            if (initNode?.type === "VariableDeclaration" && initNode.kind !== "var") {
+            const initNode = getOptionalNode(node, "init");
+            const testNode = getOptionalNode(node, "test");
+            const updateNode = getOptionalNode(node, "update");
+            const bodyNode = getNode(node, "body");
+            if (initNode?.type === "VariableDeclaration" && getString(initNode, "kind") !== "var") {
                 self.predeclareLexical([initNode]);
             }
             if (initNode) {
@@ -468,7 +456,7 @@ class Frame {
                     yield* self.evaluateExpression(initNode);
                 }
             }
-            const perIterationBindings = initNode?.type === "VariableDeclaration" && initNode.kind !== "var"
+            const perIterationBindings = initNode?.type === "VariableDeclaration" && getString(initNode, "kind") !== "var"
                 ? Array.from(self.scopes.current().keys())
                 : [];
             const nextIteration = () => {
@@ -480,20 +468,31 @@ class Frame {
             };
             nextIteration();
             while (testNode ? yield* self.evaluateExpression(testNode) : true) {
-                const exit = loopExit(yield* self.evaluateStatement(node.body), labels);
-                if (exit !== undefined)
-                    return exit;
+                const result = yield* self.evaluateStatement(bodyNode);
+                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;
                 nextIteration();
                 if (updateNode) {
                     yield* self.evaluateExpression(updateNode);
                 }
+                if (result.kind === "continue") {
+                    continue;
+                }
             }
             return { kind: "none" };
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
     evaluateForOfStatement(node, labels) {
-        const awaiting = node.await;
-        const left = node.left;
+        const awaiting = getBoolean(node, "await");
+        const left = getNode(node, "left");
         const declared = loopDeclaration(left, "for...of");
         if (declared?.lexical)
             this.scopes.push();
@@ -501,7 +500,8 @@ class Frame {
         return Effect.gen(function* () {
             if (declared?.lexical)
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
-            const right = yield* self.evaluateExpression(node.right);
+            const right = yield* self.evaluateExpression(getNode(node, "right"));
+            const body = getNode(node, "body");
             const iterator = yield* self.customIterator(right, node, awaiting);
             const cursor = iterator === undefined ? yield* self.syncIterator(right, node) : undefined;
             if (iterator === undefined && cursor === undefined) {
@@ -512,25 +512,30 @@ class Frame {
                 : awaiting
                     ? Effect.andThen(cursor?.close ?? Effect.void, Effect.yieldNow)
                     : (cursor?.close ?? Effect.void);
-            if (left.type === "RestElement" || left.type === "AssignmentPattern") {
+            let assignment;
+            if (left.type !== "VariableDeclaration" &&
+                (left.type === "Identifier" ||
+                    left.type === "MemberExpression" ||
+                    left.type === "ArrayPattern" ||
+                    left.type === "ObjectPattern")) {
+                assignment = left;
+            }
+            else if (left.type !== "VariableDeclaration") {
                 throw new InterpreterRuntimeError("Unsupported for...of binding.", left);
             }
-            const assignment = left.type === "VariableDeclaration" ? undefined : left;
             const evaluateBody = (value) => Effect.gen(function* () {
-                if (declared?.lexical) {
+                if (declared) {
                     self.scopes.push();
-                    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);
+                    if (declared.lexical)
+                        self.predeclarePattern(declared.pattern, declared.mutable, left);
+                    yield* self.declarePattern(declared.pattern, value, declared.mutable, left, declared.lexical);
                 }
                 else if (assignment) {
                     yield* self.assignPattern(assignment, value, left);
                 }
-                return yield* self.evaluateStatement(node.body);
+                return yield* self.evaluateStatement(body);
             }).pipe(Effect.ensuring(Effect.sync(() => {
-                if (declared?.lexical)
+                if (declared)
                     self.scopes.pop();
             })));
             while (true) {
@@ -548,10 +553,20 @@ class Frame {
                     }
                     return yield* Effect.failCause(bodyExit.cause);
                 }
-                const exit = loopExit(bodyExit.value, labels);
-                if (exit !== undefined) {
+                const result = bodyExit.value;
+                if (result.kind === "return") {
                     yield* close();
-                    return exit;
+                    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;
                 }
             }
         }).pipe(Effect.ensuring(Effect.sync(() => {
@@ -560,7 +575,7 @@ class Frame {
         })));
     }
     awaitValue(value, node = promiseResolutionNode) {
-        return Effect.flatMap(resolvePromise(this.runtime.runner, this.runtime.promises, value, node), (promise) => this.settlePromise(promise));
+        return Effect.flatMap(resolvePromise(this.runner, this.promises, value, node), (promise) => this.settlePromise(promise));
     }
     awaitAsyncFromSyncValue(iterator, value, node, closeOnRejection) {
         const self = this;
@@ -575,25 +590,22 @@ class Frame {
         });
     }
     syncIterator(value, node) {
-        const iterator = value instanceof ProgramArray
-            ? value.items[Symbol.iterator]()
+        const iterator = Array.isArray(value)
+            ? value[Symbol.iterator]()
             : typeof value === "string"
                 ? value[Symbol.iterator]()
-                : value instanceof Values.Map
+                : value instanceof CodeModeMap
                     ? value.map.entries()
-                    : value instanceof Values.Set
+                    : value instanceof CodeModeSet
                         ? value.set.values()
-                        : value instanceof Values.URLSearchParams
+                        : value instanceof CodeModeURLSearchParams
                             ? value.params.entries()
                             : undefined;
         if (iterator !== undefined) {
             return Effect.succeed({
                 next: Effect.sync(() => {
                     const step = iterator.next();
-                    return {
-                        done: Boolean(step.done),
-                        value: Array.isArray(step.value) ? new ProgramArray(step.value) : step.value,
-                    };
+                    return { done: Boolean(step.done), value: step.value };
                 }),
                 close: Effect.void,
             });
@@ -616,10 +628,10 @@ class Frame {
                 asynchronous: value.asynchronous,
             });
         }
-        if (!(value instanceof ProgramObject))
+        if (!isRecord(value) || isRuntimeReference(value))
             return Effect.undefined;
-        const asyncMethod = allowAsync ? get(value, AsyncIteratorSymbol) : undefined;
-        const method = asyncMethod ?? get(value, IteratorSymbol);
+        const asyncMethod = allowAsync ? Reflect.get(value, AsyncIteratorSymbol) : undefined;
+        const method = asyncMethod ?? Reflect.get(value, IteratorSymbol);
         if (method === undefined || method === null)
             return Effect.undefined;
         const self = this;
@@ -629,7 +641,7 @@ class Frame {
                 iterator: object,
                 next: object instanceof CodeModeGenerator
                     ? new GeneratorMethodReference(object, "next")
-                    : self.requireIteratorMethod(get(object, "next"), "Iterator next", node),
+                    : self.requireIteratorMethod(object.next, "Iterator next", node),
                 asynchronous: asyncMethod !== undefined && asyncMethod !== null,
             };
         });
@@ -639,7 +651,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(get(object, "done")), value: get(object, "value") };
+                return { done: Boolean(object.done), value: object.value };
             }
             const called = yield* Effect.exit(self.invokeCallable(iterator.next, [], node));
             if (!Exit.isSuccess(called)) {
@@ -649,7 +661,7 @@ class Frame {
             }
             const captured = yield* Effect.exit(Effect.sync(() => {
                 const object = self.requireIteratorObject(called.value, "Iterator next() result", node);
-                return { done: Boolean(get(object, "done")), value: get(object, "value") };
+                return { done: Boolean(object.done), value: object.value };
             }));
             if (!Exit.isSuccess(captured)) {
                 if (awaiting)
@@ -667,7 +679,7 @@ class Frame {
     closeIterator(iterator, node, awaiting = true) {
         const close = iterator.iterator instanceof CodeModeGenerator
             ? new GeneratorMethodReference(iterator.iterator, "return")
-            : get(iterator.iterator, "return");
+            : iterator.iterator.return;
         if (close === undefined || close === null)
             return iterator.asynchronous || !awaiting ? Effect.void : Effect.yieldNow;
         const self = this;
@@ -683,7 +695,7 @@ class Frame {
                     yield* Effect.yieldNow;
                 return yield* Effect.failCause(called.cause);
             }
-            const captured = yield* Effect.exit(Effect.sync(() => get(self.requireIteratorObject(called.value, "Iterator return() result", node), "value")));
+            const captured = yield* Effect.exit(Effect.sync(() => self.requireIteratorObject(called.value, "Iterator return() result", node).value));
             if (!Exit.isSuccess(captured)) {
                 if (awaiting)
                     yield* Effect.yieldNow;
@@ -694,7 +706,7 @@ class Frame {
         });
     }
     requireIteratorObject(value, context, node) {
-        if (value instanceof ProgramObject)
+        if (isRecord(value) && !isRuntimeReference(value))
             return value;
         throw new InterpreterRuntimeError(`${context} must be an object.`, node).as("TypeError");
     }
@@ -708,16 +720,20 @@ class Frame {
             return value;
         throw new InterpreterRuntimeError(`${context} must be a function.`, node).as("TypeError");
     }
-    // for...in over null/undefined iterates nothing, like JS.
-    enumerableKeys(value, node) {
-        if (value instanceof ToolReference)
-            return [...this.runtime.toolKeys(value.path)];
-        if (value === null || value === undefined)
-            return [];
-        return ownKeys(enumerableSource("for...in", value, node)).filter((key) => typeof key === "string");
+    enumerableKeys(value) {
+        if (value instanceof ToolReference) {
+            return [...this.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;
     }
     evaluateForInStatement(node, labels) {
-        const left = node.left;
+        const left = getNode(node, "left");
         const declared = loopDeclaration(left, "for...in");
         if (declared?.lexical)
             this.scopes.push();
@@ -725,33 +741,48 @@ class Frame {
         return Effect.gen(function* () {
             if (declared?.lexical)
                 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") {
+            const right = yield* self.evaluateExpression(getNode(node, "right"));
+            const body = getNode(node, "body");
+            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);
+            }
+            let assignmentName;
+            if (left.type === "Identifier") {
+                assignmentName = getString(left, "name");
+            }
+            else if (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?.lexical) {
+                    if (declared) {
                         self.scopes.push();
-                        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);
+                        if (declared.lexical)
+                            self.predeclarePattern(declared.pattern, declared.mutable, left);
+                        yield* self.declarePattern(declared.pattern, key, declared.mutable, left, declared.lexical);
                     }
                     else if (assignmentName) {
                         self.scopes.set(assignmentName, key, left);
                     }
-                    return yield* self.evaluateStatement(node.body);
+                    return yield* self.evaluateStatement(body);
                 }).pipe(Effect.ensuring(Effect.sync(() => {
-                    if (declared?.lexical)
+                    if (declared)
                         self.scopes.pop();
                 })));
-                const exit = loopExit(result, labels);
-                if (exit !== undefined)
-                    return exit;
+                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;
+                }
             }
             return { kind: "none" };
         }).pipe(Effect.ensuring(Effect.sync(() => {
@@ -760,17 +791,19 @@ class Frame {
         })));
     }
     evaluateBreakStatement(node) {
-        return node.label ? { kind: "break", label: node.label.name } : { kind: "break" };
+        const labelNode = getOptionalNode(node, "label");
+        return labelNode ? { kind: "break", label: getString(labelNode, "name") } : { kind: "break" };
     }
     evaluateContinueStatement(node) {
-        return node.label ? { kind: "continue", label: node.label.name } : { kind: "continue" };
+        const labelNode = getOptionalNode(node, "label");
+        return labelNode ? { kind: "continue", label: getString(labelNode, "name") } : { kind: "continue" };
     }
     evaluateLabeledStatement(node) {
         const labels = new Set();
         let body = node;
         while (body.type === "LabeledStatement") {
-            labels.add(body.label.name);
-            body = body.body;
+            labels.add(getString(getNode(body, "label"), "name"));
+            body = getNode(body, "body");
         }
         const evaluated = (() => {
             if (body.type === "WhileStatement")
@@ -790,12 +823,13 @@ class Frame {
             : result);
     }
     evaluateThrowStatement(node) {
-        return Effect.flatMap(this.evaluateExpression(node.argument), (value) => Effect.fail(new ProgramThrow(value)));
+        const argument = getNode(node, "argument");
+        return Effect.flatMap(this.evaluateExpression(argument), (value) => Effect.fail(new ProgramThrow(value)));
     }
     evaluateTryStatement(node) {
-        const body = node.block;
-        const handler = node.handler;
-        const finalizer = node.finalizer;
+        const body = getNode(node, "block");
+        const handler = getOptionalNode(node, "handler");
+        const finalizer = getOptionalNode(node, "finalizer");
         const self = this;
         const attempted = Effect.matchCauseEffect(this.evaluateStatement(body), {
             onFailure: (cause) => {
@@ -803,12 +837,12 @@ class Frame {
                     return Effect.failCause(cause);
                 }
                 const caught = caughtErrorValue(Cause.squash(cause));
-                const parameter = handler.param;
+                const parameter = getOptionalNode(handler, "param");
                 self.scopes.push();
                 return Effect.gen(function* () {
                     if (parameter)
                         yield* self.declarePattern(parameter, caught, true, handler);
-                    return yield* self.evaluateStatement(handler.body);
+                    return yield* self.evaluateStatement(getNode(handler, "body"));
                 }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
             },
             onSuccess: Effect.succeed,
@@ -824,24 +858,18 @@ class Frame {
         });
     }
     evaluateVariableDeclaration(node) {
-        const kind = node.kind;
+        const kind = getString(node, "kind");
+        const declarations = getArray(node, "declarations");
         const self = this;
         return Effect.gen(function* () {
-            for (const declaration of node.declarations) {
+            for (const declarationValue of declarations) {
+                const declaration = asNode(declarationValue, "declarations");
                 if (declaration.type !== "VariableDeclarator") {
                     throw new InterpreterRuntimeError("Unsupported variable declaration shape.", declaration);
                 }
-                const init = declaration.init;
-                // `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);
+                const init = getOptionalNode(declaration, "init");
+                const value = init ? yield* self.evaluateExpression(init) : undefined;
+                yield* self.declarePattern(getNode(declaration, "id"), value, kind !== "const", declaration, kind !== "var");
             }
         });
     }
@@ -849,7 +877,7 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             if (pattern.type === "Identifier") {
-                const name = pattern.name;
+                const name = getString(pattern, "name");
                 if (initialize)
                     self.scopes.initialize(name, value, node);
                 else
@@ -857,25 +885,33 @@ class Frame {
                 return;
             }
             if (pattern.type === "AssignmentPattern") {
-                const resolved = value === undefined ? yield* self.evaluateDefault(pattern) : value;
-                yield* self.declarePattern(pattern.left, resolved, mutable, node, initialize);
+                const resolved = value === undefined ? yield* self.evaluateExpression(getNode(pattern, "right")) : value;
+                yield* self.declarePattern(getNode(pattern, "left"), resolved, mutable, node, initialize);
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (!(value instanceof ProgramObject)) {
-                    throw new InterpreterRuntimeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern, "InvalidDataValue");
+                if (value === null || typeof value !== "object" || isRuntimeReference(value)) {
+                    throw new InterpreterRuntimeError("Object destructuring requires a data object or array value.", pattern, "InvalidDataValue");
                 }
                 const consumed = new Set();
-                for (const property of pattern.properties) {
+                for (const propertyValue of getArray(pattern, "properties")) {
+                    const property = asNode(propertyValue, "properties");
                     if (property.type === "RestElement") {
-                        const rest = new ProgramObject();
-                        assign(rest, value, consumed);
-                        yield* self.declarePattern(property.argument, rest, mutable, property, initialize);
+                        const rest = Object.create(null);
+                        for (const [key, item] of Object.entries(value)) {
+                            if (!consumed.has(key) && !isBlockedMember(key))
+                                rest[key] = item;
+                        }
+                        copyIteratorSymbols(value, rest, consumed);
+                        yield* self.declarePattern(getNode(property, "argument"), rest, mutable, property, initialize);
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
+                    if (isBlockedMember(String(key))) {
+                        throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, property);
+                    }
                     consumed.add(typeof key === "symbol" ? key : String(key));
-                    yield* self.declarePattern(property.value, self.destructuringPropertyValue(value, key), mutable, property, initialize);
+                    yield* self.declarePattern(getNode(property, "value"), self.destructuringPropertyValue(value, key), mutable, property, initialize);
                 }
                 return;
             }
@@ -889,7 +925,7 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             if (pattern.type === "Identifier") {
-                self.scopes.set(pattern.name, value, pattern);
+                self.scopes.set(getString(pattern, "name"), value, pattern);
                 return;
             }
             if (pattern.type === "MemberExpression") {
@@ -897,25 +933,34 @@ class Frame {
                 return;
             }
             if (pattern.type === "AssignmentPattern") {
-                const resolved = value === undefined ? yield* self.evaluateDefault(pattern) : value;
-                yield* self.assignPattern(pattern.left, resolved, node);
+                const resolved = value === undefined ? yield* self.evaluateExpression(getNode(pattern, "right")) : value;
+                yield* self.assignPattern(getNode(pattern, "left"), resolved, node);
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (!(value instanceof ProgramObject)) {
-                    throw new InterpreterRuntimeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern, "InvalidDataValue");
+                if (value === null || typeof value !== "object" || isRuntimeReference(value)) {
+                    throw new InterpreterRuntimeError("Object destructuring requires a data object or array value.", pattern, "InvalidDataValue");
                 }
+                const source = value;
                 const consumed = new Set();
-                for (const property of pattern.properties) {
+                for (const propertyValue of getArray(pattern, "properties")) {
+                    const property = asNode(propertyValue, "properties");
                     if (property.type === "RestElement") {
-                        const rest = new ProgramObject();
-                        assign(rest, value, consumed);
-                        yield* self.assignPattern(property.argument, rest, property);
+                        const rest = Object.create(null);
+                        for (const [key, item] of Object.entries(source)) {
+                            if (!consumed.has(key) && !isBlockedMember(key))
+                                rest[key] = item;
+                        }
+                        copyIteratorSymbols(source, rest, consumed);
+                        yield* self.assignPattern(getNode(property, "argument"), rest, property);
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
+                    if (isBlockedMember(String(key))) {
+                        throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, property);
+                    }
                     consumed.add(typeof key === "symbol" ? key : String(key));
-                    yield* self.assignPattern(property.value, self.destructuringPropertyValue(value, key), property);
+                    yield* self.assignPattern(getNode(property, "value"), self.destructuringPropertyValue(source, key), property);
                 }
                 return;
             }
@@ -925,11 +970,6 @@ 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* () {
@@ -938,19 +978,21 @@ class Frame {
                 throw new InterpreterRuntimeError("Array destructuring requires a supported iterable value.", pattern).as("TypeError");
             }
             let done = false;
-            for (const element of pattern.elements) {
+            for (const [index, item] of getArray(pattern, "elements").entries()) {
                 if (done) {
-                    if (element === null)
+                    if (item === null)
                         continue;
-                    yield* consume(element.type === "RestElement" ? element.argument : element, element.type === "RestElement" ? new ProgramArray() : undefined, element);
+                    const element = asNode(item, `elements[${index}]`);
+                    yield* consume(element.type === "RestElement" ? getNode(element, "argument") : element, element.type === "RestElement" ? [] : undefined, element);
                     if (element.type === "RestElement")
                         return;
                     continue;
                 }
                 const step = yield* cursor.next;
                 done = step.done;
-                if (element === null)
+                if (item === null)
                     continue;
+                const element = asNode(item, `elements[${index}]`);
                 if (element.type === "RestElement") {
                     const rest = [];
                     if (!step.done)
@@ -961,7 +1003,7 @@ class Frame {
                         if (!done)
                             rest.push(next.value);
                     }
-                    yield* consume(element.argument, new ProgramArray(rest), element);
+                    yield* consume(getNode(element, "argument"), rest, element);
                     return;
                 }
                 const consumed = consume(element, step.done ? undefined : step.value, pattern);
@@ -972,24 +1014,24 @@ class Frame {
         });
     }
     destructuringPropertyKey(property) {
-        if (property.type !== "Property" || property.kind !== "init") {
+        if (property.type !== "Property" || getString(property, "kind") !== "init") {
             throw new InterpreterRuntimeError("Unsupported object destructuring property.", property);
         }
-        const keyNode = property.key;
-        if (property.computed) {
+        const keyNode = getNode(property, "key");
+        if (getBoolean(property, "computed")) {
             return Effect.map(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value, keyNode));
         }
-        if (keyNode.type === "Identifier")
-            return Effect.succeed(keyNode.name);
-        if (keyNode.type === "Literal")
-            return Effect.succeed(String(keyNode.value));
-        throw unsupportedSyntax(keyNode.type, keyNode);
+        return Effect.succeed(keyNode.type === "Identifier" ? getString(keyNode, "name") : String(keyNode.value));
     }
     destructuringPropertyValue(source, key) {
-        if (!(source instanceof ProgramArray))
-            return get(source, key);
-        if (has(source, key))
-            return get(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 (typeof key === "string" && arrayMethods.has(key))
             return new IntrinsicReference(source, key);
         return undefined;
@@ -998,12 +1040,13 @@ class Frame {
         switch (node.type) {
             case "Literal": {
                 const regex = node.regex;
-                if (regex)
-                    return Effect.sync(() => constructRegExp([regex.pattern, regex.flags], node));
-                return Effect.sync(() => toProgram(node.value, "Literal"));
+                if (isRecord(regex) && typeof regex.pattern === "string") {
+                    return Effect.sync(() => this.constructRegExp([regex.pattern, typeof regex.flags === "string" ? regex.flags : ""], node));
+                }
+                return Effect.sync(() => boundedData(node.value, "Literal"));
             }
             case "Identifier":
-                return Effect.sync(() => this.scopes.get(node.name, node));
+                return Effect.sync(() => this.scopes.get(getString(node, "name"), node));
             case "BinaryExpression":
                 return this.evaluateBinaryExpression(node);
             case "LogicalExpression":
@@ -1016,8 +1059,8 @@ class Frame {
                 const self = this;
                 return Effect.gen(function* () {
                     let result;
-                    for (const expression of node.expressions) {
-                        result = yield* self.evaluateExpression(expression);
+                    for (const expression of getArray(node, "expressions")) {
+                        result = yield* self.evaluateExpression(asNode(expression, "expressions"));
                     }
                     return result;
                 });
@@ -1030,7 +1073,7 @@ class Frame {
             case "MemberExpression":
                 return this.readMember(node);
             case "ChainExpression":
-                return Effect.map(this.evaluateExpression(node.expression), (value) => value === OptionalShortCircuit ? undefined : value);
+                return Effect.map(this.evaluateExpression(getNode(node, "expression")), (value) => value === OptionalShortCircuit ? undefined : value);
             case "ObjectExpression":
                 return this.evaluateObjectExpression(node);
             case "ArrayExpression":
@@ -1043,7 +1086,7 @@ class Frame {
                 return this.evaluateUpdateExpression(node);
             case "AwaitExpression": {
                 // Await always suspends, including for plain values.
-                return Effect.flatMap(this.evaluateExpression(node.argument), (value) => this.awaitValue(value, node));
+                return Effect.flatMap(this.evaluateExpression(getNode(node, "argument")), (value) => this.awaitValue(value, node));
             }
             case "YieldExpression":
                 return this.evaluateYieldExpression(node);
@@ -1054,39 +1097,240 @@ class Frame {
         }
     }
     evaluateNewExpression(node) {
+        const callee = getNode(node, "callee");
+        if (callee.type !== "Identifier") {
+            throw unsupportedSyntax("NewExpression", node);
+        }
+        const name = getString(callee, "name");
+        const argNodes = getArray(node, "arguments");
+        const self = this;
+        if (name === "Promise") {
+            return Effect.flatMap(this.evaluateCallArguments(argNodes), (args) => constructPromise(self.runner, self.promises, args[0], node));
+        }
+        if (errorConstructors.has(name)) {
+            return Effect.flatMap(this.evaluateCallArguments(argNodes), (args) => name === "AggregateError"
+                ? constructAggregateErrorValue(self.runner, args, node)
+                : Effect.succeed(constructErrorValue(name, args)));
+        }
+        // Array and Object construct identically with or without new, like JS.
+        if (name === "Array") {
+            return Effect.map(this.evaluateCallArguments(argNodes), (args) => self.constructArray(args, node));
+        }
+        if (name === "Object") {
+            return Effect.map(this.evaluateCallArguments(argNodes), (args) => self.constructObject(args, node));
+        }
+        if (valueConstructors.has(name)) {
+            return Effect.gen(function* () {
+                const args = yield* self.evaluateCallArguments(argNodes);
+                switch (name) {
+                    case "Date":
+                        return yield* self.constructDate(args, node);
+                    case "RegExp":
+                        return self.constructRegExp(args, node);
+                    case "Map":
+                        return yield* self.constructMap(args[0], node);
+                    case "Set":
+                        return yield* self.constructSet(args[0], node);
+                    case "URL":
+                        return self.constructURL(args, node);
+                    default:
+                        return yield* self.constructURLSearchParams(args[0], node);
+                }
+            });
+        }
+        throw unsupportedSyntax("NewExpression", node);
+    }
+    constructArray(args, node) {
+        if (args.length !== 1)
+            return [...args];
+        const first = args[0];
+        if (typeof first !== "number")
+            return [first];
+        if (!Number.isInteger(first) || first < 0 || first > 4294967295) {
+            throw new InterpreterRuntimeError("Invalid array length.", node).as("RangeError");
+        }
+        // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
+        return new Array(first);
+    }
+    constructObject(args, node) {
+        const first = args[0];
+        if (first === null || first === undefined)
+            return {};
+        if (typeof first === "object")
+            return first;
+        throw new InterpreterRuntimeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`, node);
+    }
+    constructDate(args, node) {
+        if (args.length === 0)
+            return Effect.succeed(new CodeModeDate(Date.now()));
+        if (args.length === 1) {
+            const arg = args[0];
+            if (arg instanceof CodeModeDate)
+                return Effect.succeed(new CodeModeDate(arg.time));
+            return Effect.map(this.toDatePrimitive(arg, node), (value) => typeof value === "string"
+                ? new CodeModeDate(Date.parse(value))
+                : new CodeModeDate(new Date(coerceToNumber(value)).getTime()));
+        }
+        const parts = args.map((arg) => coerceToNumber(arg));
+        return Effect.succeed(new CodeModeDate(new Date(...parts).getTime()));
+    }
+    toDatePrimitive(value, node) {
+        if (value === null || (typeof value !== "object" && typeof value !== "function"))
+            return Effect.succeed(value);
+        const object = value;
         const self = this;
         return Effect.gen(function* () {
-            const callee = yield* self.evaluateExpression(node.callee);
-            // Globals are built with this interpreter's R; `instanceof` cannot recover the type argument.
-            const construct = callee instanceof HostFunction ? callee.construct : undefined;
-            if (construct === undefined) {
-                // `new` itself is supported, so a non-constructible callee is a TypeError like JS rather than
-                // 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 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.`
-                        : `${name} is not a constructor.`;
-                throw new InterpreterRuntimeError(message, node).as("TypeError");
-            }
-            const args = yield* self.evaluateCallArguments(node.arguments);
-            return yield* construct(args, node);
+            if (Object.hasOwn(object, "valueOf") && typeofValue(object.valueOf) === "function") {
+                const result = yield* self.runner.invokeCallable(object.valueOf, [], node);
+                if (result === null || (typeof result !== "object" && typeof result !== "function"))
+                    return result;
+            }
+            if (!Object.hasOwn(object, "toString"))
+                return coerceToString(value);
+            if (typeofValue(object.toString) === "function") {
+                const result = yield* self.runner.invokeCallable(object.toString, [], node);
+                if (result === null || (typeof result !== "object" && typeof result !== "function"))
+                    return result;
+            }
+            throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
+        });
+    }
+    constructRegExp(args, node) {
+        const first = args[0];
+        const pattern = first instanceof CodeModeRegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
+        const flagsArg = args[1];
+        if (flagsArg !== undefined && typeof flagsArg !== "string") {
+            throw new InterpreterRuntimeError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node).as("SyntaxError");
+        }
+        const flags = flagsArg ?? (first instanceof CodeModeRegExp ? first.regex.flags : "");
+        try {
+            return new CodeModeRegExp(pattern, flags);
+        }
+        catch (error) {
+            const reason = regexFailureReason(error);
+            throw new InterpreterRuntimeError(/flag/i.test(reason)
+                ? `new RegExp(...) received invalid flags ${JSON.stringify(flags)} (${reason}). Valid flags are d, g, i, m, s, u, v, and y.`
+                : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`, node).as("SyntaxError");
+        }
+    }
+    constructMap(init, node) {
+        const target = new CodeModeMap();
+        if (init === undefined || init === null)
+            return Effect.succeed(target);
+        const self = this;
+        return Effect.gen(function* () {
+            const cursor = yield* self.syncIterator(init, node);
+            if (cursor === undefined) {
+                throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node).as("TypeError");
+            }
+            while (true) {
+                const step = yield* cursor.next;
+                if (step.done)
+                    return target;
+                yield* preserveConsumerError(cursor, Effect.sync(() => {
+                    if (!isRecord(step.value) || isRuntimeReference(step.value)) {
+                        throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node).as("TypeError");
+                    }
+                    target.map.set(step.value[0], step.value[1]);
+                }));
+            }
+        });
+    }
+    constructSet(init, node) {
+        const target = new CodeModeSet();
+        if (init === undefined || init === null)
+            return Effect.succeed(target);
+        const self = this;
+        return Effect.gen(function* () {
+            const cursor = yield* self.syncIterator(init, node);
+            if (cursor === undefined) {
+                throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node).as("TypeError");
+            }
+            while (true) {
+                const step = yield* cursor.next;
+                if (step.done)
+                    return target;
+                target.set.add(step.value);
+            }
+        });
+    }
+    constructURL(args, node) {
+        if (args.length === 0) {
+            throw new InterpreterRuntimeError("new URL(...) requires a URL string and an optional base URL.", node).as("TypeError");
+        }
+        const input = urlArgument(args[0], "new URL input");
+        const base = args[1] === undefined ? undefined : urlArgument(args[1], "new URL base");
+        try {
+            return new CodeModeURL(new URL(input, base));
+        }
+        catch {
+            throw new InterpreterRuntimeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`, node).as("TypeError");
+        }
+    }
+    constructURLSearchParams(init, node) {
+        if (init === undefined)
+            return Effect.succeed(new CodeModeURLSearchParams(new URLSearchParams()));
+        if (init instanceof CodeModeURLSearchParams) {
+            return Effect.succeed(new CodeModeURLSearchParams(new URLSearchParams(init.params)));
+        }
+        if (typeof init === "string")
+            return Effect.succeed(new CodeModeURLSearchParams(new URLSearchParams(init)));
+        if (init === null || typeof init === "number" || typeof init === "boolean") {
+            return Effect.succeed(new CodeModeURLSearchParams(new URLSearchParams(coerceToString(init))));
+        }
+        const self = this;
+        return Effect.gen(function* () {
+            const cursor = yield* self.syncIterator(init, node);
+            if (cursor !== undefined) {
+                const entries = [];
+                while (true) {
+                    const step = yield* cursor.next;
+                    if (step.done) {
+                        if (entries.some((entry) => entry.length !== 2)) {
+                            throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
+                        }
+                        return new CodeModeURLSearchParams(new URLSearchParams(entries.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
+                    }
+                    entries.push(yield* preserveConsumerError(cursor, self.readURLSearchParamsPair(step.value, node)));
+                }
+            }
+            if (isRuntimeReference(init)) {
+                throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node).as("TypeError");
+            }
+            if (isCodeModeValue(init))
+                return new CodeModeURLSearchParams(new URLSearchParams());
+            const data = boundedData(init, "new URLSearchParams input");
+            if (data === null || typeof data !== "object") {
+                throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node).as("TypeError");
+            }
+            return new CodeModeURLSearchParams(new URLSearchParams(Object.fromEntries(Object.entries(data).map(([key, value]) => [key, coerceToString(value)]))));
+        });
+    }
+    readURLSearchParamsPair(value, node) {
+        const self = this;
+        return Effect.gen(function* () {
+            const cursor = yield* self.syncIterator(value, node);
+            if (cursor === undefined) {
+                throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
+            }
+            const items = [];
+            while (true) {
+                const step = yield* cursor.next;
+                if (step.done)
+                    return items;
+                items.push(yield* preserveConsumerError(cursor, Effect.sync(() => uriArgument(step.value, "URLSearchParams pair value"))));
+            }
         });
     }
     evaluateBinaryExpression(node) {
-        const operator = node.operator;
-        const left = node.left;
-        if (left.type === "PrivateIdentifier")
-            throw unsupportedSyntax(left.type, left);
+        const operator = getString(node, "operator");
         const self = this;
         return Effect.gen(function* () {
-            const lhs = yield* self.evaluateExpression(left);
-            const rhs = yield* self.evaluateExpression(node.right);
+            const lhs = yield* self.evaluateExpression(getNode(node, "left"));
+            const rhs = yield* self.evaluateExpression(getNode(node, "right"));
             if (operator === "instanceof")
                 return instanceofValue(lhs, rhs, node);
-            return toProgram(self.applyBinaryOperator(operator, lhs, rhs, node), "Binary expression result");
+            return boundedData(self.applyBinaryOperator(operator, lhs, rhs, node), "Binary expression result");
         });
     }
     applyBinaryOperator(operator, lhs, rhs, node) {
@@ -1094,16 +1338,13 @@ 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");
         }
         // Null-prototype data needs explicit primitive coercion; identity and `in` retain raw objects.
         // Dates use their default string hint for addition and loose equality, and epoch time elsewhere.
         const coerceOperand = (operand) => {
-            if (operand instanceof Values.Date) {
+            if (operand instanceof CodeModeDate) {
                 return operator === "+" || operator === "==" || operator === "!=" ? coerceToString(operand) : operand.time;
             }
             return operand !== null && typeof operand === "object" ? coerceToString(operand) : operand;
@@ -1149,33 +1390,36 @@ class Frame {
             case ">>>":
                 return l >>> r;
             case "in":
-                if (!(rhs instanceof ProgramObject)) {
+                if (rhs === null || typeof rhs !== "object") {
                     throw new InterpreterRuntimeError("The 'in' operator requires a data object on the right-hand side.", node);
                 }
-                return has(rhs, coerceOperand(lhs));
+                // Never expose properties inherited from host prototypes.
+                return Object.hasOwn(rhs, coerceOperand(lhs));
             default:
                 throw new InterpreterRuntimeError(`Unsupported binary operator '${operator}'.`, node);
         }
     }
     evaluateLogicalExpression(node) {
-        const operator = node.operator;
-        return Effect.flatMap(this.evaluateExpression(node.left), (left) => {
+        const operator = getString(node, "operator");
+        return Effect.flatMap(this.evaluateExpression(getNode(node, "left")), (left) => {
             if (operator === "&&")
-                return left ? this.evaluateExpression(node.right) : Effect.succeed(left);
+                return left ? this.evaluateExpression(getNode(node, "right")) : Effect.succeed(left);
             if (operator === "||")
-                return left ? Effect.succeed(left) : this.evaluateExpression(node.right);
+                return left ? Effect.succeed(left) : this.evaluateExpression(getNode(node, "right"));
             if (operator === "??")
-                return left !== null && left !== undefined ? Effect.succeed(left) : this.evaluateExpression(node.right);
+                return left !== null && left !== undefined
+                    ? Effect.succeed(left)
+                    : this.evaluateExpression(getNode(node, "right"));
             throw new InterpreterRuntimeError(`Unsupported logical operator '${operator}'.`, node);
         });
     }
     evaluateUnaryExpression(node) {
-        const operator = node.operator;
-        const argument = node.argument;
+        const operator = getString(node, "operator");
+        const argument = getNode(node, "argument");
         if (operator === "delete")
             return this.evaluateDeleteExpression(argument);
         // Undeclared names short-circuit, but declared TDZ bindings must still throw.
-        if (operator === "typeof" && argument.type === "Identifier" && !this.scopes.resolve(argument.name)) {
+        if (operator === "typeof" && argument.type === "Identifier" && !this.scopes.resolve(getString(argument, "name"))) {
             return Effect.succeed("undefined");
         }
         return Effect.map(this.evaluateExpression(argument), (value) => {
@@ -1188,7 +1432,7 @@ class Frame {
             if (containsOpaqueReference(value)) {
                 throw new InterpreterRuntimeError("Unary operators require data values.", node, "InvalidDataValue");
             }
-            const operand = value instanceof Values.Date
+            const operand = value instanceof CodeModeDate
                 ? value.time
                 : value !== null && typeof value === "object"
                     ? coerceToString(value)
@@ -1207,38 +1451,38 @@ class Frame {
                 default:
                     throw new InterpreterRuntimeError(`Unsupported unary operator '${operator}'.`, node);
             }
-            return toProgram(result, "Unary expression result");
+            return boundedData(result, "Unary expression result");
         });
     }
     evaluateAssignmentExpression(node) {
-        const left = node.left;
-        const operator = node.operator;
+        const left = getNode(node, "left");
+        const operator = getString(node, "operator");
         const self = this;
         return Effect.gen(function* () {
             if (operator === "??=" || operator === "||=" || operator === "&&=") {
                 return yield* self.evaluateLogicalAssignment(node, left, operator);
             }
             if (operator === "=" && (left.type === "ObjectPattern" || left.type === "ArrayPattern")) {
-                const rightValue = yield* self.evaluateExpression(node.right);
+                const rightValue = yield* self.evaluateExpression(getNode(node, "right"));
                 yield* self.assignPattern(left, rightValue, node);
                 return rightValue;
             }
             if (left.type === "Identifier") {
-                const name = left.name;
+                const name = getString(left, "name");
                 if (operator !== "=") {
                     const current = self.scopes.get(name, left);
-                    const rightValue = yield* self.evaluateExpression(node.right);
-                    const next = toProgram(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
+                    const rightValue = yield* self.evaluateExpression(getNode(node, "right"));
+                    const next = boundedData(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
                     return self.scopes.set(name, next, left);
                 }
-                const rightValue = yield* self.evaluateNamed(node.right, name);
+                const rightValue = yield* self.evaluateExpression(getNode(node, "right"));
                 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.map(self.evaluateExpression(getNode(node, "right")), (rightValue) => {
                     if (operator === "=")
                         return { write: true, next: rightValue, result: rightValue };
-                    const next = toProgram(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
+                    const next = boundedData(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
                     return { write: true, next, result: next };
                 }));
             }
@@ -1249,18 +1493,18 @@ class Frame {
         const self = this;
         const shouldAssign = (current) => operator === "??=" ? current === null || current === undefined : operator === "||=" ? !current : Boolean(current);
         if (left.type === "Identifier") {
-            const name = left.name;
+            const name = getString(left, "name");
             return Effect.gen(function* () {
                 const current = self.scopes.get(name, left);
                 if (!shouldAssign(current))
                     return current;
-                const rightValue = yield* self.evaluateNamed(node.right, name);
+                const rightValue = yield* self.evaluateExpression(getNode(node, "right"));
                 return self.scopes.set(name, rightValue, left);
             });
         }
         if (left.type === "MemberExpression") {
             return self.modifyMember(left, (current) => shouldAssign(current)
-                ? Effect.map(self.evaluateExpression(node.right), (rightValue) => ({
+                ? Effect.map(self.evaluateExpression(getNode(node, "right")), (rightValue) => ({
                     write: true,
                     next: rightValue,
                     result: rightValue,
@@ -1270,9 +1514,9 @@ class Frame {
         throw new InterpreterRuntimeError("Assignment target must be an Identifier or MemberExpression.", left);
     }
     evaluateUpdateExpression(node) {
-        const operator = node.operator;
-        const argument = node.argument;
-        const prefix = node.prefix;
+        const operator = getString(node, "operator");
+        const argument = getNode(node, "argument");
+        const prefix = getBoolean(node, "prefix");
         const increment = operator === "++" ? 1 : operator === "--" ? -1 : undefined;
         if (increment === undefined) {
             throw new InterpreterRuntimeError(`Unsupported update operator '${operator}'.`, node);
@@ -1287,7 +1531,7 @@ class Frame {
         };
         if (argument.type === "Identifier") {
             return Effect.sync(() => {
-                const name = argument.name;
+                const name = getString(argument, "name");
                 const current = operand(this.scopes.get(name, argument));
                 const next = current + increment;
                 this.scopes.set(name, next, argument);
@@ -1304,31 +1548,35 @@ class Frame {
         throw new InterpreterRuntimeError("Update target must be an Identifier or MemberExpression.", argument);
     }
     evaluateCallExpression(node) {
-        const callee = node.callee;
+        const callee = getNode(node, "callee");
+        const argNodes = getArray(node, "arguments");
         const self = this;
         return Effect.gen(function* () {
-            if (callee.type === "Super")
-                throw unsupportedSyntax(callee.type, callee);
             const callable = yield* self.evaluateExpression(callee);
             if (callable === OptionalShortCircuit)
                 return OptionalShortCircuit;
-            if ((callable === null || callable === undefined) && node.optional)
+            if ((callable === null || callable === undefined) && node.optional === true)
                 return OptionalShortCircuit;
-            const args = yield* self.evaluateCallArguments(node.arguments);
+            const args = yield* self.evaluateCallArguments(argNodes);
             return yield* self.invokeCallable(callable, args, node, callee);
         });
     }
     // The single dispatch for every invocation: call expressions and callbacks share it.
-    invokeCallable(callable, args, node, callee) {
+    invokeCallable(callable, args, node, callee = node) {
         const self = this;
         return Effect.gen(function* () {
             if (callable instanceof ToolReference) {
-                if (callable.path.length === 0) {
-                    throw new InterpreterRuntimeError("The tools root is not callable.", callee ?? node);
-                }
+                if (callable.path.length === 0)
+                    throw new InterpreterRuntimeError("The tools root is not callable.", callee);
                 return yield* self.createToolCallPromise(callable.path, args);
             }
-            if (callable instanceof ProgramFunction) {
+            if (callable instanceof PromiseMethodReference) {
+                return yield* invokePromiseMethod(self.runner, self.promises, callable, args, node);
+            }
+            if (callable instanceof PromiseInstanceMethodReference) {
+                return yield* invokePromiseInstanceMethod(self.runner, self.promises, callable, args, node);
+            }
+            if (callable instanceof CodeModeFunction) {
                 return yield* self.invokeFunction(callable, args);
             }
             if (callable instanceof GeneratorMethodReference) {
@@ -1338,26 +1586,103 @@ class Frame {
                 return callable.generator.asynchronous ? yield* self.createPromise(requested) : yield* requested;
             }
             if (callable instanceof IntrinsicReference) {
-                return yield* invokeIntrinsic(self.runtime.runner, callable, args, node);
+                return yield* invokeIntrinsic(self.runner, callable, args, node);
             }
-            if (callable instanceof PromiseInstanceMethodReference) {
-                return yield* invokePromiseInstanceMethod(self.runtime.runner, self.runtime.promises, callable, args, node);
+            if (callable instanceof GlobalMethodReference) {
+                if (callable.namespace === "console")
+                    return self.invokeConsole(callable.name, args, node);
+                if (callable.namespace === "Object" && args[0] instanceof ToolReference) {
+                    return self.invokeObjectMethodOnTools(callable.name, args[0], node);
+                }
+                if (callable.namespace === "Object" && objectMethodsPreservingIdentity.has(callable.name)) {
+                    if (callable.name === "fromEntries")
+                        return yield* invokeObjectFromEntries(self.runner, args[0], node);
+                    return invokeGlobalMethod(callable, args, node);
+                }
+                if (callable.namespace === "Array" && callable.name === "from") {
+                    return yield* invokeArrayFrom(self.runner, args, node);
+                }
+                if ((callable.namespace === "Object" || callable.namespace === "Map") && callable.name === "groupBy") {
+                    return yield* invokeGroupBy(self.runner, callable.namespace, args, node);
+                }
+                if (callable.namespace === "Math" && callable.name === "sumPrecise") {
+                    return yield* invokeMathSumPrecise(self.runner, args[0], node);
+                }
+                if (callable.namespace === "Array" && callable.name === "of") {
+                    return invokeGlobalMethod(callable, args, node);
+                }
+                return boundedData(invokeGlobalMethod(callable, args, node), `${callable.namespace}.${callable.name} result`);
+            }
+            if (callable instanceof JsonMethodReference) {
+                return yield* invokeJsonMethod(self.runner, callable.name, args, node);
+            }
+            if (callable instanceof CoercionFunction) {
+                return boundedData(invokeCoercion(callable, args, node), `${callable.name} result`);
+            }
+            if (callable instanceof UriFunction) {
+                return invokeUriFunction(callable, args, node);
+            }
+            if (callable instanceof SearchFunction) {
+                return yield* self.invokeSearch(args);
+            }
+            if (callable instanceof ErrorConstructorReference) {
+                if (callable.name === "AggregateError")
+                    return yield* constructAggregateErrorValue(self.runner, args, node);
+                return constructErrorValue(callable.name, args);
+            }
+            if (callable instanceof GlobalNamespace) {
+                // Real JS permits calling Array, Object, Date, and RegExp without new.
+                if (callable.name === "Array")
+                    return self.constructArray(args, node);
+                if (callable.name === "Object")
+                    return self.constructObject(args, node);
+                // ISO instead of the host's locale string: CodeMode date strings are
+                // deterministic and must not leak the host timezone.
+                if (callable.name === "Date")
+                    return new Date().toISOString();
+                if (callable.name === "RegExp")
+                    return self.constructRegExp(args, node);
+                if (typeofValue(callable) === "function") {
+                    throw new InterpreterRuntimeError(`Constructor ${callable.name} requires 'new'.`, node).as("TypeError");
+                }
+                throw new InterpreterRuntimeError(`${callable.name} is not a function.`, node).as("TypeError");
+            }
+            if (callable instanceof PromiseNamespace) {
+                throw new InterpreterRuntimeError("Constructor Promise requires 'new'.", node).as("TypeError");
+            }
+            if (callable instanceof SymbolNamespace) {
+                throw new InterpreterRuntimeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.", node).as("TypeError");
+            }
+            if (callable instanceof PromiseCapabilityFunction) {
+                callable.settle(args[0]);
+                return undefined;
             }
-            if (callable instanceof HostFunction)
-                return yield* callable.call(args, node);
             if (callable === undefined || callable === null) {
-                throw new InterpreterRuntimeError(`${calleeDescription(callee)} is not a function.`, callee ?? node).as("TypeError");
+                throw new InterpreterRuntimeError(`${calleeDescription(callee)} is not a function.`, callee).as("TypeError");
             }
-            throw new InterpreterRuntimeError("Only tools are callable here.", callee ?? node);
+            throw new InterpreterRuntimeError("Only tools are callable here.", callee);
         });
     }
+    invokeObjectMethodOnTools(name, ref, node) {
+        if (name === "keys") {
+            return boundedData(this.enumerableKeys(ref), "Object.keys result");
+        }
+        throw new InterpreterRuntimeError(`Object.${name}(...) cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node, "InvalidDataValue");
+    }
+    invokeConsole(name, args, node) {
+        if (!consoleMethods.has(name))
+            throw new InterpreterRuntimeError(`console.${name} is not available.`, node);
+        this.logs.push(formatConsoleMessage(name, args));
+        return undefined;
+    }
     evaluateCallArguments(argNodes) {
         const self = this;
         return Effect.gen(function* () {
             const args = [];
-            for (const argNode of argNodes) {
+            for (const [index, arg] of argNodes.entries()) {
+                const argNode = asNode(arg, `arguments[${index}]`);
                 if (argNode.type === "SpreadElement") {
-                    const spread = yield* self.evaluateExpression(argNode.argument);
+                    const spread = yield* self.evaluateExpression(getNode(argNode, "argument"));
                     const cursor = yield* self.syncIterator(spread, argNode);
                     if (cursor === undefined)
                         throw new InterpreterRuntimeError("Spread arguments require a synchronous iterable.", argNode).as("TypeError");
@@ -1376,7 +1701,8 @@ class Frame {
         });
     }
     invokeFunction(fn, args) {
-        const invocation = new Frame(this.runtime, new ScopeStack([...fn.capturedScopes, new Map()]));
+        const invocation = new Interpreter(this.executeTool, this.invokeSearch, this.toolKeys, this.promises, this.logs);
+        invocation.scopes = new ScopeStack([...fn.capturedScopes, new Map()]);
         const run = Effect.gen(function* () {
             // Seed all parameters first so defaults cannot fall through to same-named outer bindings.
             const paramScope = invocation.scopes.current();
@@ -1387,14 +1713,12 @@ class Frame {
             }
             for (const [index, parameter] of fn.parameters.entries()) {
                 if (parameter.type === "RestElement") {
-                    yield* invocation.declarePattern(parameter.argument, new ProgramArray(args.slice(index)), true, parameter, true);
+                    yield* invocation.declarePattern(getNode(parameter, "argument"), 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;
             }
@@ -1404,7 +1728,12 @@ class Frame {
             return Effect.succeed(this.createGenerator(invocation, run, fn.async));
         if (!fn.async)
             return run;
-        return this.runtime.promises.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, self)));
+        // 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.runner, value, fn.body, box))), (promise) => {
+            box.promise = promise;
+            return promise;
+        });
     }
     createGenerator(invocation, run, asynchronous) {
         const state = { started: false, completed: false, draining: false, pending: [], pendingIndex: 0 };
@@ -1422,20 +1751,20 @@ class Frame {
                 if (state.draining)
                     return Deferred.await(request.response);
                 state.draining = true;
-                return Effect.andThen(this.runtime.promises.fork(invocation
+                return Effect.andThen(this.promises.fork(invocation
                     .completeGeneratorRequests(state, true)
                     .pipe(Effect.ensuring(Effect.sync(() => (state.draining = false))))), Deferred.await(request.response));
             }
             if (state.completed) {
                 if (kind === "throw")
                     return Effect.fail(new ProgramThrow(value));
-                return Effect.succeed(record({ value: kind === "return" ? value : undefined, done: true }));
+                return Effect.succeed({ 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(record({ value, done: true }));
+                return Effect.succeed({ value, done: true });
             }
             state.pending.push(request);
             if (state.available) {
@@ -1455,12 +1784,12 @@ class Frame {
                     const active = state.active;
                     state.active = undefined;
                     if (active) {
-                        Deferred.doneUnsafe(active.response, Exit.isSuccess(exit) ? Exit.succeed(record({ value: exit.value, done: true })) : exit);
+                        Deferred.doneUnsafe(active.response, Exit.isSuccess(exit) ? Exit.succeed({ value: exit.value, done: true }) : exit);
                     }
                     yield* invocation.completeGeneratorRequests(state, asynchronous);
                     state.completed = true;
                 });
-                return Effect.andThen(this.runtime.promises.fork(body), Deferred.await(request.response));
+                return Effect.andThen(this.promises.fork(body), Deferred.await(request.response));
             }
             return Deferred.await(request.response);
         });
@@ -1479,10 +1808,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(record({ value: resolved.value, done: true })) : resolved);
+                    Deferred.doneUnsafe(pending.response, Exit.isSuccess(resolved) ? Exit.succeed({ value: resolved.value, done: true }) : resolved);
                     continue;
                 }
-                Deferred.doneUnsafe(pending.response, Exit.succeed(record({ value: pending.kind === "return" ? pending.value : undefined, done: true })));
+                Deferred.doneUnsafe(pending.response, Exit.succeed({ value: pending.kind === "return" ? pending.value : undefined, done: true }));
             }
         });
     }
@@ -1505,12 +1834,12 @@ class Frame {
         return request;
     }
     evaluateYieldExpression(node) {
-        const argument = node.argument;
+        const argument = getOptionalNode(node, "argument");
         const self = this;
         return Effect.gen(function* () {
             if (!self.generatorState)
                 throw new InterpreterRuntimeError("yield is only valid inside a generator.", node);
-            if (node.delegate) {
+            if (node.delegate === true) {
                 const value = argument ? yield* self.evaluateExpression(argument) : undefined;
                 return yield* self.delegateYield(value, node);
             }
@@ -1523,7 +1852,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(record({ value, done: false })));
+        Deferred.doneUnsafe(state.active.response, Exit.succeed({ value, done: false }));
         state.active = undefined;
         return Effect.flatMap(this.takeGeneratorRequest(state), (request) => {
             state.active = request;
@@ -1539,11 +1868,11 @@ class Frame {
     delegateYield(value, node) {
         const self = this;
         return Effect.gen(function* () {
-            if (value instanceof ProgramArray ||
+            if (Array.isArray(value) ||
                 typeof value === "string" ||
-                value instanceof Values.Map ||
-                value instanceof Values.Set ||
-                value instanceof Values.URLSearchParams) {
+                value instanceof CodeModeMap ||
+                value instanceof CodeModeSet ||
+                value instanceof CodeModeURLSearchParams) {
                 const cursor = yield* self.syncIterator(value, node);
                 if (!cursor)
                     throw new InterpreterRuntimeError("Built-in iterator is unavailable.", node);
@@ -1576,7 +1905,7 @@ class Frame {
                     ? iterator.next
                     : iterator.iterator instanceof CodeModeGenerator
                         ? new GeneratorMethodReference(iterator.iterator, kind)
-                        : get(iterator.iterator, kind);
+                        : iterator.iterator[kind];
                 if (method === undefined || method === null) {
                     if (kind === "return")
                         return yield* Effect.fail(new GeneratorReturn(input));
@@ -1585,10 +1914,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(get(result, "done"));
+                const done = Boolean(result.done);
                 const resultValue = self.generatorAsync && !iterator.asynchronous
-                    ? yield* self.awaitAsyncFromSyncValue(iterator, get(result, "value"), node, kind !== "return" && !done)
-                    : get(result, "value");
+                    ? yield* self.awaitAsyncFromSyncValue(iterator, result.value, node, kind !== "return" && !done)
+                    : result.value;
                 if (done) {
                     if (kind === "return")
                         return yield* Effect.fail(new GeneratorReturn(resultValue));
@@ -1610,27 +1939,42 @@ class Frame {
         });
     }
     evaluateObjectExpression(node) {
-        const objectValue = new ProgramObject();
+        const objectValue = Object.create(null);
+        const properties = getArray(node, "properties");
         const self = this;
         return Effect.gen(function* () {
-            for (const property of node.properties) {
+            for (const propertyValue of properties) {
+                const property = asNode(propertyValue, "properties");
                 if (property.type === "SpreadElement") {
-                    const spread = yield* self.evaluateExpression(property.argument);
-                    if (spread === null || spread === undefined)
+                    const spread = yield* self.evaluateExpression(getNode(property, "argument"));
+                    if (spread === null || spread === undefined || isCodeModeValue(spread))
                         continue;
-                    assign(objectValue, enumerableSource("Object spread", spread, property));
+                    if (typeof spread !== "object" || Array.isArray(spread) || isRuntimeReference(spread)) {
+                        throw new InterpreterRuntimeError("Object spread requires a data object.", property, "InvalidDataValue");
+                    }
+                    for (const [key, value] of Object.entries(spread)) {
+                        if (isBlockedMember(key))
+                            throw new InterpreterRuntimeError(`Property '${key}' is not available.`, property);
+                        objectValue[key] = value;
+                    }
+                    copyIteratorSymbols(spread, objectValue);
                     continue;
                 }
-                if (property.kind !== "init") {
+                if (property.type !== "Property") {
+                    throw new InterpreterRuntimeError("Only standard object properties are supported.", property);
+                }
+                if (getString(property, "kind") !== "init") {
                     throw new InterpreterRuntimeError("Only init object properties are supported.", property);
                 }
-                const keyNode = property.key;
+                const keyNode = getNode(property, "key");
+                const valueNode = getNode(property, "value");
+                const computed = getBoolean(property, "computed");
                 let key;
-                if (property.computed) {
+                if (computed) {
                     key = self.toPropertyKey(yield* self.evaluateExpression(keyNode), keyNode);
                 }
                 else if (keyNode.type === "Identifier") {
-                    key = keyNode.name;
+                    key = getString(keyNode, "name");
                 }
                 else if (keyNode.type === "Literal") {
                     key = self.toPropertyKey(keyNode.value, keyNode);
@@ -1638,28 +1982,28 @@ class Frame {
                 else {
                     throw new InterpreterRuntimeError("Unsupported object property key shape.", keyNode);
                 }
-                const name = key === IteratorSymbol
-                    ? "[Symbol.iterator]"
-                    : key === AsyncIteratorSymbol
-                        ? "[Symbol.asyncIterator]"
-                        : String(key);
-                set(objectValue, key, yield* self.evaluateNamed(property.value, name));
+                if (isBlockedMember(String(key))) {
+                    throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, keyNode);
+                }
+                Reflect.set(objectValue, key, yield* self.evaluateExpression(valueNode));
             }
             return objectValue;
         });
     }
     evaluateArrayExpression(node) {
+        const elements = getArray(node, "elements");
         const values = [];
         const self = this;
         return Effect.gen(function* () {
-            for (const element of node.elements) {
-                if (element === null) {
+            for (const elementValue of elements) {
+                if (elementValue === null) {
                     // A literal elision is a real hole, like JS: extend length without an own index.
                     values.length += 1;
                     continue;
                 }
+                const element = asNode(elementValue, "elements");
                 if (element.type === "SpreadElement") {
-                    const spread = yield* self.evaluateExpression(element.argument);
+                    const spread = yield* self.evaluateExpression(getNode(element, "argument"));
                     const cursor = yield* self.syncIterator(spread, element);
                     if (cursor === undefined)
                         throw new InterpreterRuntimeError("Array spread requires a synchronous iterable.", element).as("TypeError");
@@ -1674,32 +2018,32 @@ class Frame {
                     values.push(yield* self.evaluateExpression(element));
                 }
             }
-            return new ProgramArray(values);
+            return values;
         });
     }
     evaluateTemplateLiteral(node) {
-        const quasis = node.quasis;
-        const expressions = node.expressions;
+        const quasis = getArray(node, "quasis");
+        const expressions = getArray(node, "expressions");
         let output = "";
         const self = this;
         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.
-                if (typeof quasi.value.cooked !== "string") {
+                const quasi = asNode(quasis[index], "quasis");
+                const rawValue = quasi.value;
+                if (!isRecord(rawValue) || typeof rawValue.cooked !== "string") {
                     throw new InterpreterRuntimeError("Invalid template literal quasi.", quasi);
                 }
-                output += quasi.value.cooked;
+                output += rawValue.cooked;
                 if (index < expressions.length) {
-                    const raw = yield* self.evaluateExpression(expressions[index]);
-                    output += coerceToString(toProgram(raw, "Template interpolation"));
+                    const raw = yield* self.evaluateExpression(asNode(expressions[index], "expressions"));
+                    output += coerceToString(boundedData(raw, "Template interpolation"));
                 }
             }
             return output;
         });
     }
     evaluateConditionalExpression(node) {
-        return Effect.flatMap(this.evaluateExpression(node.test), (test) => this.evaluateExpression(test ? node.consequent : node.alternate));
+        return Effect.flatMap(this.evaluateExpression(getNode(node, "test")), (test) => this.evaluateExpression(getNode(node, test ? "consequent" : "alternate")));
     }
     applyCompoundAssignment(operator, current, incoming, node) {
         if (!compoundOperators.has(operator)) {
@@ -1708,23 +2052,21 @@ class Frame {
         return this.applyBinaryOperator(operator.slice(0, -1), current, incoming, node);
     }
     getMemberReference(node, operation = "read") {
-        const objectNode = node.object;
-        const propertyNode = node.property;
-        if (objectNode.type === "Super")
-            throw unsupportedSyntax(objectNode.type, objectNode);
-        if (propertyNode.type === "PrivateIdentifier")
-            throw unsupportedSyntax(propertyNode.type, propertyNode);
+        const objectNode = getNode(node, "object");
+        const propertyNode = getNode(node, "property");
+        const computed = getBoolean(node, "computed");
+        const optional = node.optional === true;
         const self = this;
         return Effect.gen(function* () {
             const objectValue = yield* self.evaluateExpression(objectNode);
             if (objectValue === OptionalShortCircuit)
                 return OptionalShortCircuit;
-            if ((objectValue === null || objectValue === undefined) && node.optional)
+            if ((objectValue === null || objectValue === undefined) && optional)
                 return OptionalShortCircuit;
-            const key = node.computed
+            const key = computed
                 ? self.toPropertyKey(yield* self.evaluateExpression(propertyNode), propertyNode)
                 : propertyNode.type === "Identifier"
-                    ? propertyNode.name
+                    ? getString(propertyNode, "name")
                     : self.toPropertyKey(yield* self.evaluateExpression(propertyNode), propertyNode);
             if (objectValue instanceof ToolReference) {
                 if (typeof key !== "string") {
@@ -1732,17 +2074,38 @@ class Frame {
                 }
                 return new ToolReference([...objectValue.path, key]);
             }
-            if (objectValue instanceof HostFunction || objectValue instanceof HostNamespace) {
-                // Unknown static members read as undefined so feature detection works like native JS.
-                return new ComputedValue(objectValue.member(key, propertyNode));
+            if (objectValue instanceof PromiseNamespace) {
+                if (typeof key === "string" && promiseStatics.has(key)) {
+                    return new PromiseMethodReference(key);
+                }
+                throw new InterpreterRuntimeError(`Promise.${String(key)} is not available. Available: Promise.all, Promise.allSettled, Promise.race, Promise.any, Promise.resolve, and Promise.reject; consume promises with await.`, 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 (objectValue instanceof SymbolNamespace) {
+                if (key === "asyncIterator")
+                    return new ComputedValue(AsyncIteratorSymbol);
+                if (key === "iterator")
+                    return new ComputedValue(IteratorSymbol);
+                return new ComputedValue(undefined);
+            }
+            if (objectValue instanceof GlobalNamespace) {
+                if (typeof key === "string" && isBlockedMember(key)) {
+                    throw new InterpreterRuntimeError(`${objectValue.name}.${key} is not available.`, propertyNode);
+                }
+                if (typeof key !== "string")
+                    return new ComputedValue(undefined);
+                if (objectValue.name === "Math" && mathConstants.has(key)) {
+                    return new ComputedValue(Math[key]);
+                }
+                if (objectValue.name === "JSON") {
+                    if (jsonStatics.has(key))
+                        return new JsonMethodReference(key);
+                    return new ComputedValue(undefined);
+                }
+                if (globalStaticMembers[objectValue.name]?.has(key)) {
+                    return new GlobalMethodReference(objectValue.name, key);
+                }
+                // Unknown static members read as undefined so feature detection works like native JS.
+                return new ComputedValue(undefined);
             }
             if (typeof objectValue === "string") {
                 if (key === "length")
@@ -1759,12 +2122,29 @@ class Frame {
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof Values.Date) {
+            if (objectValue instanceof CoercionFunction) {
+                if (typeof key === "string" && isBlockedMember(key)) {
+                    throw new InterpreterRuntimeError(`${objectValue.name}.${key} is not available.`, propertyNode);
+                }
+                if (typeof key !== "string")
+                    return new ComputedValue(undefined);
+                if (objectValue.name === "Number" && numberConstants.has(key)) {
+                    return new ComputedValue(Number[key]);
+                }
+                if (objectValue.name === "Number" && numberStatics.has(key)) {
+                    return new GlobalMethodReference("Number", key);
+                }
+                if (objectValue.name === "String" && stringStatics.has(key)) {
+                    return new GlobalMethodReference("String", key);
+                }
+                return new ComputedValue(undefined);
+            }
+            if (objectValue instanceof CodeModeDate) {
                 if (typeof key === "string" && dateMethods.has(key))
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof Values.RegExp) {
+            if (objectValue instanceof CodeModeRegExp) {
                 if (key === "lastIndex")
                     return { target: objectValue, key };
                 if (typeof key === "string" && regexpProperties.has(key)) {
@@ -1774,21 +2154,21 @@ class Frame {
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof Values.Map) {
+            if (objectValue instanceof CodeModeMap) {
                 if (key === "size")
                     return new ComputedValue(objectValue.map.size);
                 if (typeof key === "string" && mapMethods.has(key))
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof Values.Set) {
+            if (objectValue instanceof CodeModeSet) {
                 if (key === "size")
                     return new ComputedValue(objectValue.set.size);
                 if (typeof key === "string" && setMethods.has(key))
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof Values.URL) {
+            if (objectValue instanceof CodeModeURL) {
                 if (key === "searchParams") {
                     return new ComputedValue(objectValue.searchParams);
                 }
@@ -1798,7 +2178,7 @@ class Frame {
                     return { target: objectValue, key };
                 return new ComputedValue(undefined);
             }
-            if (objectValue instanceof Values.URLSearchParams) {
+            if (objectValue instanceof CodeModeURLSearchParams) {
                 if (key === "size")
                     return new ComputedValue(objectValue.params.size);
                 if (typeof key === "string" && urlSearchParamsMethods.has(key)) {
@@ -1807,7 +2187,7 @@ class Frame {
                 return new ComputedValue(undefined);
             }
             // Reject unknown promise properties so a missing await cannot hide.
-            if (objectValue instanceof Values.Promise) {
+            if (objectValue instanceof CodeModePromise) {
                 if (key === "then" || key === "catch" || key === "finally") {
                     return new PromiseInstanceMethodReference(objectValue, key);
                 }
@@ -1823,16 +2203,31 @@ 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");
+                throw new InterpreterRuntimeError("Runtime references are opaque and do not expose properties.", objectNode, "InvalidDataValue");
+            }
+            if (typeof objectValue !== "object" || objectValue === null) {
+                throw new InterpreterRuntimeError("Cannot access a property on a non-object value.", objectNode);
+            }
+            if (typeof key === "string" && isBlockedMember(key)) {
+                throw new InterpreterRuntimeError(`Property '${key}' is not available.`, propertyNode);
             }
-            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 };
         });
     }
     readMember(node) {
-        const self = this;
         return Effect.map(this.getMemberReference(node), (reference) => {
             if (reference === OptionalShortCircuit)
                 return OptionalShortCircuit;
@@ -1840,22 +2235,26 @@ class Frame {
                 return reference.value;
             if (reference === undefined || isOpaqueMemberReference(reference))
                 return reference;
-            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;
+            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 CodeModeRegExp)
+                return reference.target.lastIndex;
+            if (reference.target instanceof CodeModeURL) {
+                return Reflect.get(reference.target.url, reference.key);
+            }
+            return Reflect.get(reference.target, reference.key);
         });
     }
     writeMember(node, value) {
         return this.modifyMember(node, () => Effect.succeed({ write: true, next: value, result: value }));
     }
     evaluateDeleteExpression(argument) {
-        const target = argument.type === "ChainExpression" ? argument.expression : argument;
+        const target = argument.type === "ChainExpression" ? getNode(argument, "expression") : argument;
         if (target.type !== "MemberExpression") {
             throw new InterpreterRuntimeError("Only data fields may be deleted.", argument);
         }
@@ -1865,26 +2264,33 @@ class Frame {
             if (reference instanceof ComputedValue ||
                 reference === undefined ||
                 isOpaqueMemberReference(reference) ||
-                reference.target instanceof Values.URL) {
+                reference.target instanceof CodeModeURL) {
                 throw new InterpreterRuntimeError("Only data fields may be deleted.", target, "InvalidDataValue");
             }
-            if (reference.target instanceof Values.RegExp) {
+            if (reference.target instanceof CodeModeRegExp) {
                 return Reflect.deleteProperty(reference.target.regex, reference.key);
             }
-            return remove(reference.target, reference.key);
+            return Reflect.deleteProperty(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, "write");
+            const reference = yield* self.getMemberReference(node);
             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)
@@ -1893,15 +2299,24 @@ class Frame {
         });
     }
     readReferenceValue(reference, key) {
-        if (reference.target instanceof Values.URL) {
+        if (reference.target instanceof CodeModeURL) {
             return Reflect.get(reference.target.url, key);
         }
-        if (reference.target instanceof Values.RegExp)
+        if (reference.target instanceof CodeModeRegExp)
             return reference.target.lastIndex;
-        return get(reference.target, key);
+        return Reflect.get(reference.target, key);
     }
     assignToReference(reference, key, next, node) {
-        if (reference.target instanceof Values.URL) {
+        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 CodeModeURL) {
             const property = key;
             if (!urlWritableProperties.has(property)) {
                 throw new InterpreterRuntimeError(`URL.${property} is read-only.`, node).as("TypeError");
@@ -1917,17 +2332,13 @@ class Frame {
                 throw new InterpreterRuntimeError(`URL.${property} received an invalid value.`, node).as("TypeError");
             }
         }
-        if (reference.target instanceof Values.RegExp) {
+        if (reference.target instanceof CodeModeRegExp) {
             reference.target.lastIndex = next;
             return;
         }
         const target = reference.target;
-        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");
+        rejectCircularInsertion(target, next, "Object assignment result", node);
+        Reflect.set(target, key, next);
     }
     toPropertyKey(value, node) {
         if (typeof value === "string" || typeof value === "number") {