@opencode/codemode 0.0.0-dev-19530 → 2.0.0

package/dist/interpreter/runtime.js

@@ -1,17 +1,25 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
-import { toProgram } from "../data.js";
+import { ToolRuntimeError, toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
-import { AsyncIteratorSymbol, GeneratorReturn, InterpreterRuntimeError, IteratorSymbol, locate, OptionalShortCircuit, ProgramThrow, rangeError, unsupportedSyntax, } from "./model.js";
+import { AsyncIteratorSymbol, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, IteratorSymbol, OptionalShortCircuit, PromiseInstanceMethodReference, ProgramThrow, unsupportedSyntax, } from "./model.js";
 import { caughtErrorValue } from "./errors.js";
 import { globals } from "./globals.js";
-import { assign, Callable, define, get, has, hasPrototype, keys, NativeFunction, parseArrayIndex, ProgramArray, ProgramDate, ProgramFunction, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramSet, ProgramURLSearchParams, record, remove, set, } from "./objects.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 { PromiseRuntime, resolvePromise, resolvePromiseValue } from "./promises.js";
-import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
+import { invokePromiseInstanceMethod, PromiseRuntime, resolvePromise, resolvePromiseValue } from "./promises.js";
+import { containsOpaqueReference, describeValue, isRuntimeReference, rejectCircularInsertion, typeofValue, } from "./references.js";
 import { ScopeStack } from "./scope.js";
-import { constructRegExp } from "../stdlib/regexp.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 } from "../stdlib/value.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) => {
@@ -42,16 +50,37 @@ const calleeDescription = (callee) => {
     }
     return "The called value";
 };
-// OrdinaryHasInstance: walk the left operand's chain looking for the constructor's `prototype`.
+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 Callable)) {
-        throw new InterpreterRuntimeError("The right-hand side of 'instanceof' is not callable.", node);
-    }
-    const prototype = get(rhs, "prototype");
-    if (!(prototype instanceof ProgramObject)) {
-        throw new InterpreterRuntimeError("The right-hand side of 'instanceof' has no 'prototype' object.", node);
-    }
-    return hasPrototype(lhs, prototype);
+    if (rhs instanceof HostFunction && rhs.instanceOf !== undefined)
+        return rhs.instanceOf(lhs);
+    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) {
@@ -141,6 +170,10 @@ const loopDeclaration = (left, statement) => {
         lexical: kind !== "var",
     };
 };
+const isOpaqueMemberReference = (value) => value instanceof ToolReference ||
+    value instanceof PromiseInstanceMethodReference ||
+    value instanceof IntrinsicReference ||
+    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 {
@@ -148,29 +181,29 @@ export class Runtime {
     search;
     toolKeys;
     promises;
-    prototypes;
     logs;
     runner;
+    /** Built-in globals by name, unaffected by program shadowing. */
+    builtins;
     root;
-    constructor(executeTool, search, toolKeys, promises, prototypes, logs = [], extraGlobals = () => []) {
+    constructor(executeTool, search, toolKeys, promises, logs = [], extraGlobals = () => []) {
         this.executeTool = executeTool;
         this.search = search;
         this.toolKeys = toolKeys;
         this.promises = promises;
-        this.prototypes = prototypes;
         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 = {
-            invokeCallable: (callable, thisValue, args, node) => this.root.invokeCallable(callable, thisValue, args, node),
+            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),
-            prototypes,
         };
-        for (const [name, value] of [...globals(this), ...extraGlobals(this)]) {
+        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);
@@ -216,7 +249,10 @@ class Frame {
     }
     // Fork at the call site so admission and hooks occur when the call is made.
     createToolCallPromise(path, args) {
-        return this.runtime.promises.create(Effect.suspend(() => this.runtime.executeTool(path, args)));
+        return this.createPromise(Effect.suspend(() => this.runtime.executeTool(path, args)));
+    }
+    createPromise(effect) {
+        return this.runtime.promises.create(effect);
     }
     // Fiber exits make settlement idempotent; yielding prevents inline continuation.
     settlePromise(promise) {
@@ -289,7 +325,7 @@ class Frame {
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
     createFunction(node, name = node.type === "ArrowFunctionExpression" ? "" : (node.id?.name ?? "")) {
-        return new ProgramFunction(this.runtime.prototypes.Function, name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+        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) {
@@ -469,7 +505,7 @@ class Frame {
             const iterator = yield* self.customIterator(right, node, awaiting);
             const cursor = iterator === undefined ? yield* self.syncIterator(right, node) : undefined;
             if (iterator === undefined && cursor === undefined) {
-                throw new InterpreterRuntimeError(`${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, or URLSearchParams, or custom iterator value.`, node);
+                throw new InterpreterRuntimeError(`${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, or URLSearchParams, or custom iterator value.`, node).as("TypeError");
             }
             const close = () => iterator
                 ? self.closeIterator(iterator, node, awaiting)
@@ -543,21 +579,20 @@ class Frame {
             ? value.items[Symbol.iterator]()
             : typeof value === "string"
                 ? value[Symbol.iterator]()
-                : value instanceof ProgramMap
+                : value instanceof Values.Map
                     ? value.map.entries()
-                    : value instanceof ProgramSet
+                    : value instanceof Values.Set
                         ? value.set.values()
-                        : value instanceof ProgramURLSearchParams
+                        : value instanceof Values.URLSearchParams
                             ? value.params.entries()
                             : undefined;
         if (iterator !== undefined) {
-            const proto = this.runtime.prototypes.Array;
             return Effect.succeed({
                 next: Effect.sync(() => {
                     const step = iterator.next();
                     return {
                         done: Boolean(step.done),
-                        value: Array.isArray(step.value) ? new ProgramArray(proto, step.value) : step.value,
+                        value: Array.isArray(step.value) ? new ProgramArray(step.value) : step.value,
                     };
                 }),
                 close: Effect.void,
@@ -572,6 +607,15 @@ class Frame {
             });
     }
     customIterator(value, node, allowAsync = true) {
+        if (value instanceof CodeModeGenerator) {
+            if (value.asynchronous && !allowAsync)
+                return Effect.undefined;
+            return Effect.succeed({
+                iterator: value,
+                next: new GeneratorMethodReference(value, "next"),
+                asynchronous: value.asynchronous,
+            });
+        }
         if (!(value instanceof ProgramObject))
             return Effect.undefined;
         const asyncMethod = allowAsync ? get(value, AsyncIteratorSymbol) : undefined;
@@ -579,11 +623,13 @@ class Frame {
         if (method === undefined || method === null)
             return Effect.undefined;
         const self = this;
-        return Effect.map(this.invokeCallable(this.requireIteratorMethod(method, "Iterator method", node), value, [], node), (iterator) => {
-            const object = self.requireIteratorObject(iterator, "Iterator method result", node);
+        return Effect.map(this.invokeCallable(this.requireIteratorMethod(method, "Iterator method", node), [], node), (iterator) => {
+            const object = self.requireIterator(iterator, node);
             return {
                 iterator: object,
-                next: self.requireIteratorMethod(get(object, "next"), "Iterator next", node),
+                next: object instanceof CodeModeGenerator
+                    ? new GeneratorMethodReference(object, "next")
+                    : self.requireIteratorMethod(get(object, "next"), "Iterator next", node),
                 asynchronous: asyncMethod !== undefined && asyncMethod !== null,
             };
         });
@@ -592,10 +638,10 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             if (iterator.asynchronous) {
-                const object = self.requireIteratorObject(yield* self.awaitValue(yield* self.invokeCallable(iterator.next, iterator.iterator, [], node)), "Iterator next() result", node);
+                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") };
             }
-            const called = yield* Effect.exit(self.invokeCallable(iterator.next, iterator.iterator, [], node));
+            const called = yield* Effect.exit(self.invokeCallable(iterator.next, [], node));
             if (!Exit.isSuccess(called)) {
                 if (awaiting)
                     yield* Effect.yieldNow;
@@ -619,17 +665,19 @@ class Frame {
         });
     }
     closeIterator(iterator, node, awaiting = true) {
-        const close = get(iterator.iterator, "return");
+        const close = iterator.iterator instanceof CodeModeGenerator
+            ? new GeneratorMethodReference(iterator.iterator, "return")
+            : get(iterator.iterator, "return");
         if (close === undefined || close === null)
             return iterator.asynchronous || !awaiting ? Effect.void : Effect.yieldNow;
         const self = this;
         return Effect.gen(function* () {
             const method = self.requireIteratorMethod(close, "Iterator return", node);
             if (iterator.asynchronous) {
-                self.requireIteratorObject(yield* self.awaitValue(yield* self.invokeCallable(method, iterator.iterator, [], node)), "Iterator return() result", node);
+                self.requireIteratorObject(yield* self.awaitValue(yield* self.invokeCallable(method, [], node)), "Iterator return() result", node);
                 return;
             }
-            const called = yield* Effect.exit(self.invokeCallable(method, iterator.iterator, [], node));
+            const called = yield* Effect.exit(self.invokeCallable(method, [], node));
             if (!Exit.isSuccess(called)) {
                 if (awaiting)
                     yield* Effect.yieldNow;
@@ -648,12 +696,17 @@ class Frame {
     requireIteratorObject(value, context, node) {
         if (value instanceof ProgramObject)
             return value;
-        throw new InterpreterRuntimeError(`${context} must be an object.`, node);
+        throw new InterpreterRuntimeError(`${context} must be an object.`, node).as("TypeError");
+    }
+    requireIterator(value, node) {
+        return value instanceof CodeModeGenerator
+            ? value
+            : this.requireIteratorObject(value, "Iterator method result", node);
     }
     requireIteratorMethod(value, context, node) {
         if (typeofValue(value) === "function")
             return value;
-        throw new InterpreterRuntimeError(`${context} must be a function.`, node);
+        throw new InterpreterRuntimeError(`${context} must be a function.`, node).as("TypeError");
     }
     // for...in over null/undefined iterates nothing, like JS.
     enumerableKeys(value, node) {
@@ -661,7 +714,7 @@ class Frame {
             return [...this.runtime.toolKeys(value.path)];
         if (value === null || value === undefined)
             return [];
-        return keys(enumerableSource(this.runtime.runner, "for...in", value, node));
+        return ownKeys(enumerableSource("for...in", value, node)).filter((key) => typeof key === "string");
     }
     evaluateForInStatement(node, labels) {
         const left = node.left;
@@ -749,7 +802,7 @@ class Frame {
                 if (cause.reasons.some(Cause.isInterruptReason) || Cause.squash(cause) instanceof GeneratorReturn || !handler) {
                     return Effect.failCause(cause);
                 }
-                const caught = caughtErrorValue(self.runtime.runner, Cause.squash(cause));
+                const caught = caughtErrorValue(Cause.squash(cause));
                 const parameter = handler.param;
                 self.scopes.push();
                 return Effect.gen(function* () {
@@ -815,14 +868,14 @@ class Frame {
                 const consumed = new Set();
                 for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
-                        const rest = new ProgramObject(self.runtime.prototypes.Object);
+                        const rest = new ProgramObject();
                         assign(rest, value, consumed);
                         yield* self.declarePattern(property.argument, rest, mutable, property, initialize);
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
                     consumed.add(typeof key === "symbol" ? key : String(key));
-                    yield* self.declarePattern(property.value, get(value, key), mutable, property, initialize);
+                    yield* self.declarePattern(property.value, self.destructuringPropertyValue(value, key), mutable, property, initialize);
                 }
                 return;
             }
@@ -855,14 +908,14 @@ class Frame {
                 const consumed = new Set();
                 for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
-                        const rest = new ProgramObject(self.runtime.prototypes.Object);
+                        const rest = new ProgramObject();
                         assign(rest, value, consumed);
                         yield* self.assignPattern(property.argument, rest, property);
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
                     consumed.add(typeof key === "symbol" ? key : String(key));
-                    yield* self.assignPattern(property.value, get(value, key), property);
+                    yield* self.assignPattern(property.value, self.destructuringPropertyValue(value, key), property);
                 }
                 return;
             }
@@ -882,14 +935,14 @@ class Frame {
         return Effect.gen(function* () {
             const cursor = yield* self.syncIterator(value, pattern);
             if (cursor === undefined) {
-                throw new InterpreterRuntimeError("Array destructuring requires a supported iterable value.", pattern);
+                throw new InterpreterRuntimeError("Array destructuring requires a supported iterable value.", pattern).as("TypeError");
             }
             let done = false;
             for (const element of pattern.elements) {
                 if (done) {
                     if (element === null)
                         continue;
-                    yield* consume(element.type === "RestElement" ? element.argument : element, element.type === "RestElement" ? new ProgramArray(self.runtime.prototypes.Array) : undefined, element);
+                    yield* consume(element.type === "RestElement" ? element.argument : element, element.type === "RestElement" ? new ProgramArray() : undefined, element);
                     if (element.type === "RestElement")
                         return;
                     continue;
@@ -908,7 +961,7 @@ class Frame {
                         if (!done)
                             rest.push(next.value);
                     }
-                    yield* consume(element.argument, new ProgramArray(self.runtime.prototypes.Array, rest), element);
+                    yield* consume(element.argument, new ProgramArray(rest), element);
                     return;
                 }
                 const consumed = consume(element, step.done ? undefined : step.value, pattern);
@@ -932,13 +985,22 @@ class Frame {
             return Effect.succeed(String(keyNode.value));
         throw unsupportedSyntax(keyNode.type, keyNode);
     }
+    destructuringPropertyValue(source, key) {
+        if (!(source instanceof ProgramArray))
+            return get(source, key);
+        if (has(source, key))
+            return get(source, key);
+        if (typeof key === "string" && arrayMethods.has(key))
+            return new IntrinsicReference(source, key);
+        return undefined;
+    }
     evaluateExpression(node) {
         switch (node.type) {
             case "Literal": {
                 const regex = node.regex;
                 if (regex)
-                    return Effect.sync(() => constructRegExp(this.runtime.prototypes, [regex.pattern, regex.flags], node));
-                return Effect.sync(() => toProgram(this.runtime.prototypes, node.value, "Literal"));
+                    return Effect.sync(() => constructRegExp([regex.pattern, regex.flags], node));
+                return Effect.sync(() => toProgram(node.value, "Literal"));
             }
             case "Identifier":
                 return Effect.sync(() => this.scopes.get(node.name, node));
@@ -996,7 +1058,7 @@ class Frame {
         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 NativeFunction ? callee.construct : undefined;
+            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
@@ -1004,13 +1066,13 @@ class Frame {
                 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 NativeFunction
+                    : callee instanceof HostFunction
                         ? `new ${name}(...) is not supported; call ${name}(...) without new instead.`
                         : `${name} is not a constructor.`;
-                throw new InterpreterRuntimeError(message, node);
+                throw new InterpreterRuntimeError(message, node).as("TypeError");
             }
             const args = yield* self.evaluateCallArguments(node.arguments);
-            return yield* construct(args, callee, node);
+            return yield* construct(args, node);
         });
     }
     evaluateBinaryExpression(node) {
@@ -1024,7 +1086,7 @@ class Frame {
             const rhs = yield* self.evaluateExpression(node.right);
             if (operator === "instanceof")
                 return instanceofValue(lhs, rhs, node);
-            return toProgram(self.runtime.prototypes, self.applyBinaryOperator(operator, lhs, rhs, node), "Binary expression result");
+            return toProgram(self.applyBinaryOperator(operator, lhs, rhs, node), "Binary expression result");
         });
     }
     applyBinaryOperator(operator, lhs, rhs, node) {
@@ -1041,7 +1103,7 @@ class Frame {
         // 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 ProgramDate) {
+            if (operand instanceof Values.Date) {
                 return operator === "+" || operator === "==" || operator === "!=" ? coerceToString(operand) : operand.time;
             }
             return operand !== null && typeof operand === "object" ? coerceToString(operand) : operand;
@@ -1126,7 +1188,7 @@ class Frame {
             if (containsOpaqueReference(value)) {
                 throw new InterpreterRuntimeError("Unary operators require data values.", node, "InvalidDataValue");
             }
-            const operand = value instanceof ProgramDate
+            const operand = value instanceof Values.Date
                 ? value.time
                 : value !== null && typeof value === "object"
                     ? coerceToString(value)
@@ -1145,7 +1207,7 @@ class Frame {
                 default:
                     throw new InterpreterRuntimeError(`Unsupported unary operator '${operator}'.`, node);
             }
-            return toProgram(this.runtime.prototypes, result, "Unary expression result");
+            return toProgram(result, "Unary expression result");
         });
     }
     evaluateAssignmentExpression(node) {
@@ -1166,7 +1228,7 @@ class Frame {
                 if (operator !== "=") {
                     const current = self.scopes.get(name, left);
                     const rightValue = yield* self.evaluateExpression(node.right);
-                    const next = toProgram(self.runtime.prototypes, self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
+                    const next = toProgram(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
                     return self.scopes.set(name, next, left);
                 }
                 const rightValue = yield* self.evaluateNamed(node.right, name);
@@ -1176,7 +1238,7 @@ class Frame {
                 return yield* self.modifyMember(left, (current) => Effect.map(self.evaluateExpression(node.right), (rightValue) => {
                     if (operator === "=")
                         return { write: true, next: rightValue, result: rightValue };
-                    const next = toProgram(self.runtime.prototypes, self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
+                    const next = toProgram(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
                     return { write: true, next, result: next };
                 }));
             }
@@ -1241,37 +1303,23 @@ class Frame {
         }
         throw new InterpreterRuntimeError("Update target must be an Identifier or MemberExpression.", argument);
     }
-    // EvaluateCall: a member callee supplies its base object as `this`; anything else calls with undefined.
     evaluateCallExpression(node) {
         const callee = node.callee;
         const self = this;
         return Effect.gen(function* () {
             if (callee.type === "Super")
                 throw unsupportedSyntax(callee.type, callee);
-            const { callable, thisValue } = callee.type === "MemberExpression"
-                ? yield* self.readMethod(callee)
-                : { callable: yield* self.evaluateExpression(callee), thisValue: undefined };
+            const callable = yield* self.evaluateExpression(callee);
             if (callable === OptionalShortCircuit)
                 return OptionalShortCircuit;
             if ((callable === null || callable === undefined) && node.optional)
                 return OptionalShortCircuit;
             const args = yield* self.evaluateCallArguments(node.arguments);
-            return yield* self.invokeCallable(callable, thisValue, args, node, callee);
-        });
-    }
-    readMethod(node) {
-        return Effect.map(this.getMemberReference(node), (reference) => {
-            if (reference === OptionalShortCircuit)
-                return { callable: OptionalShortCircuit, thisValue: undefined };
-            if (reference instanceof ToolReference)
-                return { callable: reference, thisValue: undefined };
-            if ("value" in reference)
-                return { callable: reference.value, thisValue: undefined };
-            return { callable: this.readReference(reference, node), thisValue: reference.receiver };
+            return yield* self.invokeCallable(callable, args, node, callee);
         });
     }
     // The single dispatch for every invocation: call expressions and callbacks share it.
-    invokeCallable(callable, thisValue, args, node, callee) {
+    invokeCallable(callable, args, node, callee) {
         const self = this;
         return Effect.gen(function* () {
             if (callable instanceof ToolReference) {
@@ -1280,11 +1328,27 @@ class Frame {
                 }
                 return yield* self.createToolCallPromise(callable.path, args);
             }
-            if (callable instanceof ProgramFunction)
+            if (callable instanceof ProgramFunction) {
                 return yield* self.invokeFunction(callable, args);
-            if (callable instanceof NativeFunction)
-                return yield* callable.call(thisValue, args, node);
-            throw new InterpreterRuntimeError(`${calleeDescription(callee)} is not a function.`, callee ?? node);
+            }
+            if (callable instanceof GeneratorMethodReference) {
+                if (callable.kind === "iterator")
+                    return callable.generator;
+                const requested = callable.generator.request(callable.kind, args[0], node);
+                return callable.generator.asynchronous ? yield* self.createPromise(requested) : yield* requested;
+            }
+            if (callable instanceof IntrinsicReference) {
+                return yield* invokeIntrinsic(self.runtime.runner, callable, args, node);
+            }
+            if (callable instanceof PromiseInstanceMethodReference) {
+                return yield* invokePromiseInstanceMethod(self.runtime.runner, self.runtime.promises, callable, args, node);
+            }
+            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("Only tools are callable here.", callee ?? node);
         });
     }
     evaluateCallArguments(argNodes) {
@@ -1296,7 +1360,7 @@ class Frame {
                     const spread = yield* self.evaluateExpression(argNode.argument);
                     const cursor = yield* self.syncIterator(spread, argNode);
                     if (cursor === undefined)
-                        throw new InterpreterRuntimeError("Spread arguments require a synchronous iterable.", argNode);
+                        throw new InterpreterRuntimeError("Spread arguments require a synchronous iterable.", argNode).as("TypeError");
                     while (true) {
                         const step = yield* cursor.next;
                         if (step.done)
@@ -1312,7 +1376,6 @@ class Frame {
         });
     }
     invokeFunction(fn, args) {
-        const self = this;
         const invocation = new Frame(this.runtime, 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.
@@ -1324,7 +1387,7 @@ class Frame {
             }
             for (const [index, parameter] of fn.parameters.entries()) {
                 if (parameter.type === "RestElement") {
-                    yield* invocation.declarePattern(parameter.argument, new ProgramArray(self.runtime.prototypes.Array, args.slice(index)), true, parameter, true);
+                    yield* invocation.declarePattern(parameter.argument, new ProgramArray(args.slice(index)), true, parameter, true);
                     break;
                 }
                 yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
@@ -1347,12 +1410,10 @@ class Frame {
         const state = { started: false, completed: false, draining: false, pending: [], pendingIndex: 0 };
         invocation.generatorState = state;
         invocation.generatorAsync = asynchronous;
-        const protos = this.runtime.prototypes;
-        const result = (value, done) => record(protos.Object, { value, done });
-        const request = (kind, value, node) => {
+        const generator = new CodeModeGenerator(asynchronous, (kind, value, node) => {
             const request = { kind, value, response: Deferred.makeUnsafe() };
             if (!asynchronous && state.active) {
-                return Effect.fail(new InterpreterRuntimeError("Generator is already running.", node));
+                return Effect.fail(new InterpreterRuntimeError("Generator is already running.", node).as("TypeError"));
             }
             if (asynchronous && (state.completed || (!state.started && kind !== "next"))) {
                 state.started = true;
@@ -1368,13 +1429,13 @@ class Frame {
             if (state.completed) {
                 if (kind === "throw")
                     return Effect.fail(new ProgramThrow(value));
-                return Effect.succeed(result(kind === "return" ? value : undefined, true));
+                return Effect.succeed(record({ value: kind === "return" ? value : undefined, done: true }));
             }
             if (!state.started && kind !== "next") {
                 state.completed = true;
                 if (kind === "throw")
                     return Effect.fail(new ProgramThrow(value));
-                return Effect.succeed(result(value, true));
+                return Effect.succeed(record({ value, done: true }));
             }
             state.pending.push(request);
             if (state.available) {
@@ -1394,7 +1455,7 @@ class Frame {
                     const active = state.active;
                     state.active = undefined;
                     if (active) {
-                        Deferred.doneUnsafe(active.response, Exit.isSuccess(exit) ? Exit.succeed(result(exit.value, true)) : exit);
+                        Deferred.doneUnsafe(active.response, Exit.isSuccess(exit) ? Exit.succeed(record({ value: exit.value, done: true })) : exit);
                     }
                     yield* invocation.completeGeneratorRequests(state, asynchronous);
                     state.completed = true;
@@ -1402,13 +1463,11 @@ class Frame {
                 return Effect.andThen(this.runtime.promises.fork(body), Deferred.await(request.response));
             }
             return Deferred.await(request.response);
-        };
-        const generator = new ProgramGenerator(asynchronous ? protos.AsyncGenerator : protos.Generator, asynchronous, request);
+        });
         return generator;
     }
     completeGeneratorRequests(state, asynchronous) {
         const self = this;
-        const result = (value, done) => record(self.runtime.prototypes.Object, { value, done });
         return Effect.gen(function* () {
             while (true) {
                 const pending = self.dequeueGeneratorRequest(state);
@@ -1420,10 +1479,10 @@ class Frame {
                 }
                 if (asynchronous && pending.kind === "return") {
                     const resolved = yield* Effect.exit(self.awaitValue(pending.value));
-                    Deferred.doneUnsafe(pending.response, Exit.isSuccess(resolved) ? Exit.succeed(result(resolved.value, true)) : resolved);
+                    Deferred.doneUnsafe(pending.response, Exit.isSuccess(resolved) ? Exit.succeed(record({ value: resolved.value, done: true })) : resolved);
                     continue;
                 }
-                Deferred.doneUnsafe(pending.response, Exit.succeed(result(pending.kind === "return" ? pending.value : undefined, true)));
+                Deferred.doneUnsafe(pending.response, Exit.succeed(record({ value: pending.kind === "return" ? pending.value : undefined, done: true })));
             }
         });
     }
@@ -1464,7 +1523,7 @@ class Frame {
         const state = this.generatorState;
         if (!state?.active)
             throw new InterpreterRuntimeError("Generator has no active request.", node);
-        Deferred.doneUnsafe(state.active.response, Exit.succeed(record(this.runtime.prototypes.Object, { value, done: false })));
+        Deferred.doneUnsafe(state.active.response, Exit.succeed(record({ value, done: false })));
         state.active = undefined;
         return Effect.flatMap(this.takeGeneratorRequest(state), (request) => {
             state.active = request;
@@ -1482,9 +1541,9 @@ class Frame {
         return Effect.gen(function* () {
             if (value instanceof ProgramArray ||
                 typeof value === "string" ||
-                value instanceof ProgramMap ||
-                value instanceof ProgramSet ||
-                value instanceof ProgramURLSearchParams) {
+                value instanceof Values.Map ||
+                value instanceof Values.Set ||
+                value instanceof Values.URLSearchParams) {
                 const cursor = yield* self.syncIterator(value, node);
                 if (!cursor)
                     throw new InterpreterRuntimeError("Built-in iterator is unavailable.", node);
@@ -1502,25 +1561,29 @@ class Frame {
                     }
                     if (error instanceof ProgramThrow) {
                         yield* cursor.close;
-                        throw new InterpreterRuntimeError("The delegated iterator does not provide a throw() method.", node);
+                        throw new InterpreterRuntimeError("The delegated iterator does not provide a throw() method.", node).as("TypeError");
                     }
                     return yield* Effect.failCause(resumed.cause);
                 }
             }
             const iterator = yield* self.customIterator(value, node, self.generatorAsync);
             if (!iterator)
-                throw new InterpreterRuntimeError("yield* requires a compatible iterable value.", node);
+                throw new InterpreterRuntimeError("yield* requires a compatible iterable value.", node).as("TypeError");
             let kind = "next";
             let input = undefined;
             while (true) {
-                const method = kind === "next" ? iterator.next : get(iterator.iterator, kind);
+                const method = kind === "next"
+                    ? iterator.next
+                    : iterator.iterator instanceof CodeModeGenerator
+                        ? new GeneratorMethodReference(iterator.iterator, kind)
+                        : get(iterator.iterator, kind);
                 if (method === undefined || method === null) {
                     if (kind === "return")
                         return yield* Effect.fail(new GeneratorReturn(input));
                     yield* self.closeIterator(iterator, node, self.generatorAsync);
-                    throw new InterpreterRuntimeError("The delegated iterator does not provide a throw() method.", node);
+                    throw new InterpreterRuntimeError("The delegated iterator does not provide a throw() method.", node).as("TypeError");
                 }
-                const called = yield* self.invokeCallable(self.requireIteratorMethod(method, `Iterator ${kind}`, node), iterator.iterator, [input], node);
+                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 resultValue = self.generatorAsync && !iterator.asynchronous
@@ -1547,7 +1610,7 @@ class Frame {
         });
     }
     evaluateObjectExpression(node) {
-        const objectValue = new ProgramObject(this.runtime.prototypes.Object);
+        const objectValue = new ProgramObject();
         const self = this;
         return Effect.gen(function* () {
             for (const property of node.properties) {
@@ -1555,7 +1618,7 @@ class Frame {
                     const spread = yield* self.evaluateExpression(property.argument);
                     if (spread === null || spread === undefined)
                         continue;
-                    assign(objectValue, enumerableSource(self.runtime.runner, "Object spread", spread, property));
+                    assign(objectValue, enumerableSource("Object spread", spread, property));
                     continue;
                 }
                 if (property.kind !== "init") {
@@ -1580,7 +1643,7 @@ class Frame {
                     : key === AsyncIteratorSymbol
                         ? "[Symbol.asyncIterator]"
                         : String(key);
-                define(objectValue, key, yield* self.evaluateNamed(property.value, name));
+                set(objectValue, key, yield* self.evaluateNamed(property.value, name));
             }
             return objectValue;
         });
@@ -1599,7 +1662,7 @@ class Frame {
                     const spread = yield* self.evaluateExpression(element.argument);
                     const cursor = yield* self.syncIterator(spread, element);
                     if (cursor === undefined)
-                        throw new InterpreterRuntimeError("Array spread requires a synchronous iterable.", element);
+                        throw new InterpreterRuntimeError("Array spread requires a synchronous iterable.", element).as("TypeError");
                     while (true) {
                         const step = yield* cursor.next;
                         if (step.done)
@@ -1611,7 +1674,7 @@ class Frame {
                     values.push(yield* self.evaluateExpression(element));
                 }
             }
-            return new ProgramArray(self.runtime.prototypes.Array, values);
+            return new ProgramArray(values);
         });
     }
     evaluateTemplateLiteral(node) {
@@ -1629,7 +1692,7 @@ class Frame {
                 output += quasi.value.cooked;
                 if (index < expressions.length) {
                     const raw = yield* self.evaluateExpression(expressions[index]);
-                    output += coerceToString(toProgram(self.runtime.prototypes, raw, "Template interpolation"));
+                    output += coerceToString(toProgram(raw, "Template interpolation"));
                 }
             }
             return output;
@@ -1644,7 +1707,7 @@ class Frame {
         }
         return this.applyBinaryOperator(operator.slice(0, -1), current, incoming, node);
     }
-    getMemberReference(node) {
+    getMemberReference(node, operation = "read") {
         const objectNode = node.object;
         const propertyNode = node.property;
         if (objectNode.type === "Super")
@@ -1669,49 +1732,123 @@ class Frame {
                 }
                 return new ToolReference([...objectValue.path, key]);
             }
-            if (objectValue instanceof ProgramObject)
-                return { target: objectValue, key, receiver: objectValue };
-            // Primitives read through their wrapper prototype without being boxed; strings own length and indexes.
-            const protos = self.runtime.prototypes;
+            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));
+            }
+            // Values have no prototype chain, so `.constructor` resolves to the owning built-in directly.
+            if (operation === "read" &&
+                key === "constructor" &&
+                !(objectValue instanceof ProgramObject && has(objectValue, key))) {
+                const name = constructorName(objectValue);
+                if (name !== undefined)
+                    return new ComputedValue(self.runtime.builtins.get(name));
+            }
             if (typeof objectValue === "string") {
                 if (key === "length")
-                    return { value: objectValue.length };
+                    return new ComputedValue(objectValue.length);
                 const index = typeof key === "symbol" ? undefined : parseArrayIndex(key);
                 if (index !== undefined)
-                    return { value: objectValue[index] };
-                return { target: protos.String, key, receiver: objectValue };
+                    return new ComputedValue(objectValue[index]);
+                if (typeof key === "string" && stringMethods.has(key))
+                    return new IntrinsicReference(objectValue, key);
+                return new ComputedValue(undefined);
+            }
+            if (typeof objectValue === "number") {
+                if (typeof key === "string" && numberMethods.has(key))
+                    return new IntrinsicReference(objectValue, key);
+                return new ComputedValue(undefined);
+            }
+            if (objectValue instanceof Values.Date) {
+                if (typeof key === "string" && dateMethods.has(key))
+                    return new IntrinsicReference(objectValue, key);
+                return new ComputedValue(undefined);
+            }
+            if (objectValue instanceof Values.RegExp) {
+                if (key === "lastIndex")
+                    return { target: objectValue, key };
+                if (typeof key === "string" && regexpProperties.has(key)) {
+                    return new ComputedValue(objectValue.regex[key]);
+                }
+                if (typeof key === "string" && regexpMethods.has(key))
+                    return new IntrinsicReference(objectValue, key);
+                return new ComputedValue(undefined);
+            }
+            if (objectValue instanceof Values.Map) {
+                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 (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 (key === "searchParams") {
+                    return new ComputedValue(objectValue.searchParams);
+                }
+                if (typeof key === "string" && urlMethods.has(key))
+                    return new IntrinsicReference(objectValue, key);
+                if (typeof key === "string" && urlProperties.has(key))
+                    return { target: objectValue, key };
+                return new ComputedValue(undefined);
+            }
+            if (objectValue instanceof Values.URLSearchParams) {
+                if (key === "size")
+                    return new ComputedValue(objectValue.params.size);
+                if (typeof key === "string" && urlSearchParamsMethods.has(key)) {
+                    return new IntrinsicReference(objectValue, key);
+                }
+                return new ComputedValue(undefined);
+            }
+            // Reject unknown promise properties so a missing await cannot hide.
+            if (objectValue instanceof Values.Promise) {
+                if (key === "then" || key === "catch" || key === "finally") {
+                    return new PromiseInstanceMethodReference(objectValue, key);
+                }
+                throw new InterpreterRuntimeError("This value is an un-awaited Promise; await it first - e.g. `const result = await tools.ns.tool(...)`.", objectNode, "InvalidDataValue");
+            }
+            if (objectValue instanceof CodeModeGenerator) {
+                if (key === "next" || key === "return" || key === "throw") {
+                    return new GeneratorMethodReference(objectValue, key);
+                }
+                if ((key === IteratorSymbol && !objectValue.asynchronous) ||
+                    (key === AsyncIteratorSymbol && objectValue.asynchronous)) {
+                    return new GeneratorMethodReference(objectValue, "iterator");
+                }
+                return new ComputedValue(undefined);
             }
-            if (typeof objectValue === "number")
-                return { target: protos.Number, key, receiver: objectValue };
-            if (typeof objectValue === "boolean")
-                return { target: protos.Boolean, key, receiver: objectValue };
-            if (objectValue === null || objectValue === undefined) {
-                throw new InterpreterRuntimeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode);
+            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("Cannot access a property on a non-object value.", objectNode);
         });
     }
-    readReference(reference, node) {
-        // Reject unknown promise properties so a missing await cannot hide.
-        if (reference.target instanceof ProgramPromise && !has(reference.target, reference.key)) {
-            throw new InterpreterRuntimeError("This value is an un-awaited Promise; await it first - e.g. `const result = await tools.ns.tool(...)`.", node.object, "InvalidDataValue");
-        }
-        try {
-            return get(reference.target, reference.key, reference.receiver);
-        }
-        catch (error) {
-            throw locate(error, node);
-        }
-    }
     readMember(node) {
+        const self = this;
         return Effect.map(this.getMemberReference(node), (reference) => {
             if (reference === OptionalShortCircuit)
                 return OptionalShortCircuit;
-            if (reference instanceof ToolReference)
-                return reference;
-            if ("value" in reference)
+            if (reference instanceof ComputedValue)
                 return reference.value;
-            return this.readReference(reference, node);
+            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;
         });
     }
     writeMember(node, value) {
@@ -1722,50 +1859,75 @@ class Frame {
         if (target.type !== "MemberExpression") {
             throw new InterpreterRuntimeError("Only data fields may be deleted.", argument);
         }
-        return Effect.map(this.getMemberReference(target), (reference) => {
+        return Effect.map(this.getMemberReference(target, "delete"), (reference) => {
             if (reference === OptionalShortCircuit)
                 return true;
-            if (reference instanceof ToolReference || "value" in reference || reference.receiver !== reference.target) {
+            if (reference instanceof ComputedValue ||
+                reference === undefined ||
+                isOpaqueMemberReference(reference) ||
+                reference.target instanceof Values.URL) {
                 throw new InterpreterRuntimeError("Only data fields may be deleted.", target, "InvalidDataValue");
             }
-            if (remove(reference.target, reference.key))
-                return true;
-            throw new InterpreterRuntimeError(`Cannot delete property '${String(reference.key)}'.`, target);
+            if (reference.target instanceof Values.RegExp) {
+                return Reflect.deleteProperty(reference.target.regex, reference.key);
+            }
+            return remove(reference.target, reference.key);
         });
     }
     // Resolve side-effecting object and key expressions exactly once.
     modifyMember(node, compute) {
         const self = this;
         return Effect.gen(function* () {
-            const reference = yield* self.getMemberReference(node);
-            if (reference === OptionalShortCircuit || reference instanceof ToolReference || "value" in reference) {
+            const reference = yield* self.getMemberReference(node, "write");
+            if (reference === OptionalShortCircuit ||
+                reference instanceof ComputedValue ||
+                reference === undefined ||
+                isOpaqueMemberReference(reference)) {
                 throw new InterpreterRuntimeError("Only data fields may be assigned.", node);
             }
-            if (reference.receiver !== reference.target) {
-                throw new InterpreterRuntimeError(`Cannot create property '${String(reference.key)}' on ${typeof reference.receiver} '${String(reference.receiver)}'.`, node);
-            }
             const key = reference.key;
-            const { write, next, result } = yield* compute(self.readReference(reference, node));
+            const { write, next, result } = yield* compute(self.readReferenceValue(reference, key));
             if (write)
-                self.assignToReference(reference.target, key, next, node);
+                self.assignToReference(reference, key, next, node);
             return result;
         });
     }
-    assignToReference(target, key, next, node) {
-        rejectCircularInsertion(target, next, target instanceof ProgramArray ? "Array assignment result" : "Object assignment result", node);
-        const written = (() => {
+    readReferenceValue(reference, key) {
+        if (reference.target instanceof Values.URL) {
+            return Reflect.get(reference.target.url, key);
+        }
+        if (reference.target instanceof Values.RegExp)
+            return reference.target.lastIndex;
+        return get(reference.target, key);
+    }
+    assignToReference(reference, key, next, node) {
+        if (reference.target instanceof Values.URL) {
+            const property = key;
+            if (!urlWritableProperties.has(property)) {
+                throw new InterpreterRuntimeError(`URL.${property} is read-only.`, node).as("TypeError");
+            }
             try {
-                return set(target, key, next);
+                const url = reference.target.url;
+                url[property] = uriArgument(next, `URL.${property} value`);
+                return;
             }
             catch (error) {
-                throw locate(error, node);
+                if (error instanceof InterpreterRuntimeError || error instanceof ToolRuntimeError)
+                    throw error;
+                throw new InterpreterRuntimeError(`URL.${property} received an invalid value.`, node).as("TypeError");
             }
-        })();
-        if (written)
+        }
+        if (reference.target instanceof Values.RegExp) {
+            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 && key === "length")
-            throw rangeError("Invalid array length", node);
-        throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node);
+        if (target instanceof ProgramArray)
+            throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
+        throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node).as("TypeError");
     }
     toPropertyKey(value, node) {
         if (typeof value === "string" || typeof value === "number") {