@opencode/codemode 0.0.0-beta-19365 → 0.0.0-beta-19381

package/dist/interpreter/runtime.js

@@ -1,36 +1,23 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
 import { isBlockedMember, ToolRuntimeError, toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
-import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, CoercionFunction, ComputedValue, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, GeneratorMethodReference, GeneratorReturn, 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, toPrimitive, } from "./methods.js";
-import { preserveConsumerError } from "./iterator.js";
-import { constructPromise, invokePromiseInstanceMethod, invokePromiseMethod, PromiseRuntime, resolvePromise, resolvePromiseValue, } from "./promises.js";
+import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, isRecord, IteratorSymbol, IteratorSymbols, 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 { preserveConsumerError } from "./runner.js";
+import { invokePromiseInstanceMethod, PromiseRuntime, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, isRuntimeReference, rejectCircularInsertion, typeofValue } from "./references.js";
 import { ScopeStack } from "./scope.js";
-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 { coerceToNumber, coerceToString, compoundOperators, errorBrandName, errorConstructors, invokeCoercion, valueConstructors, } from "../stdlib/value.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 { coerceToNumber, coerceToString, compoundOperators } from "../stdlib/value.js";
 import { Values } 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);
@@ -56,35 +43,8 @@ const calleeDescription = (callee) => {
     return "The called value";
 };
 const instanceofValue = (lhs, rhs, node) => {
-    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 Values.Date;
-            case "RegExp":
-                return lhs instanceof Values.RegExp;
-            case "Map":
-                return lhs instanceof Values.Map;
-            case "Set":
-                return lhs instanceof Values.Set;
-            case "URL":
-                return lhs instanceof Values.URL;
-            case "URLSearchParams":
-                return lhs instanceof Values.URLSearchParams;
-            case "Array":
-                return Array.isArray(lhs);
-            case "Object":
-                return lhs !== null && (typeof lhs === "object" || typeofValue(lhs) === "function");
-        }
-    }
-    if (rhs instanceof PromiseNamespace)
-        return lhs instanceof Values.Promise;
-    if (rhs instanceof CoercionFunction && (rhs.name === "Number" || rhs.name === "String" || rhs.name === "Boolean")) {
-        return false;
-    }
+    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 = []) => {
@@ -127,11 +87,8 @@ const loopDeclaration = (left, statement) => {
     };
 };
 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 copyIteratorSymbols = (source, target, consumed) => {
     for (const symbol of IteratorSymbols) {
@@ -140,61 +97,46 @@ const copyIteratorSymbols = (source, target, consumed) => {
     }
 };
 const promiseResolutionNode = { type: "PromiseResolution", start: 0, end: 0 };
-export class Interpreter {
-    scopes;
+/** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
+export class Runtime {
     executeTool;
-    invokeSearch;
+    search;
     toolKeys;
-    logs;
     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]);
+    logs;
+    runner;
+    root;
+    constructor(executeTool, search, toolKeys, promises, logs = []) {
         this.executeTool = executeTool;
-        this.invokeSearch = invokeSearch;
+        this.search = search;
         this.toolKeys = toolKeys;
-        this.logs = logs;
         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 });
+        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),
+        };
+        for (const [name, value] of globals(this))
+            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;
     }
     run(program) {
         const self = this;
@@ -219,20 +161,20 @@ export class Interpreter {
                 }
             }
             // The implicit async body adopts returned promises before copy-out.
-            value = yield* resolvePromiseValue(self.runner, value, program);
+            value = yield* resolvePromiseValue(self.runtime.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.executeTool(path, args)));
+        return this.createPromise(Effect.suspend(() => this.runtime.executeTool(path, args)));
     }
     createPromise(effect) {
-        return this.promises.create(effect);
+        return this.runtime.promises.create(effect);
     }
     // Fiber exits make settlement idempotent; yielding prevents inline continuation.
     settlePromise(promise) {
-        const promises = this.promises;
+        const promises = this.runtime.promises;
         return Effect.suspend(() => {
             promises.markObserved(promise);
             return Effect.flatMap(promises.await(promise), (exit) => Effect.andThen(Effect.yieldNow, exit));
@@ -555,7 +497,7 @@ export class Interpreter {
         })));
     }
     awaitValue(value, node = promiseResolutionNode) {
-        return Effect.flatMap(resolvePromise(this.runner, this.promises, value, node), (promise) => this.settlePromise(promise));
+        return Effect.flatMap(resolvePromise(this.runtime.runner, this.runtime.promises, value, node), (promise) => this.settlePromise(promise));
     }
     awaitAsyncFromSyncValue(iterator, value, node, closeOnRejection) {
         const self = this;
@@ -702,7 +644,7 @@ export class Interpreter {
     }
     enumerableKeys(value) {
         if (value instanceof ToolReference) {
-            return [...this.toolKeys(value.path)];
+            return [...this.runtime.toolKeys(value.path)];
         }
         if (Array.isArray(value)) {
             return Object.keys(value);
@@ -1012,7 +954,7 @@ export class Interpreter {
             case "Literal": {
                 const regex = node.regex;
                 if (regex)
-                    return Effect.sync(() => this.constructRegExp([regex.pattern, regex.flags], node));
+                    return Effect.sync(() => constructRegExp([regex.pattern, regex.flags], node));
                 return Effect.sync(() => toProgram(node.value, "Literal"));
             }
             case "Identifier":
@@ -1067,208 +1009,15 @@ export class Interpreter {
         }
     }
     evaluateNewExpression(node) {
-        const callee = node.callee;
-        if (callee.type !== "Identifier") {
-            throw unsupportedSyntax("NewExpression", node);
-        }
-        const name = callee.name;
-        const argNodes = 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 Values.Date(Date.now()));
-        if (args.length === 1) {
-            const arg = args[0];
-            if (arg instanceof Values.Date)
-                return Effect.succeed(new Values.Date(arg.time));
-            return Effect.map(toPrimitive(this.runner, arg, "number", node), (value) => typeof value === "string"
-                ? new Values.Date(Date.parse(value))
-                : new Values.Date(new Date(coerceToNumber(value)).getTime()));
-        }
-        const parts = args.map((arg) => coerceToNumber(arg));
-        return Effect.succeed(new Values.Date(new Date(...parts).getTime()));
-    }
-    constructRegExp(args, node) {
-        const first = args[0];
-        const pattern = first instanceof Values.RegExp ? 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 Values.RegExp ? first.regex.flags : "");
-        try {
-            return new Values.RegExp(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 Values.Map();
-        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 Values.Set();
-        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 Values.URL(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 Values.URLSearchParams(new URLSearchParams()));
-        if (init instanceof Values.URLSearchParams) {
-            return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init.params)));
-        }
-        if (typeof init === "string")
-            return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init)));
-        if (init === null || typeof init === "number" || typeof init === "boolean") {
-            return Effect.succeed(new Values.URLSearchParams(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 Values.URLSearchParams(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 (Values.isValue(init))
-                return new Values.URLSearchParams(new URLSearchParams());
-            const data = toProgram(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 Values.URLSearchParams(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"))));
-            }
+            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)
+                throw unsupportedSyntax("NewExpression", node);
+            const args = yield* self.evaluateCallArguments(node.arguments);
+            return yield* construct(args, node);
         });
     }
     evaluateBinaryExpression(node) {
@@ -1522,12 +1271,6 @@ export class Interpreter {
                 }
                 return yield* self.createToolCallPromise(callable.path, args);
             }
-            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);
             }
@@ -1538,95 +1281,19 @@ export class Interpreter {
                 return callable.generator.asynchronous ? yield* self.createPromise(requested) : yield* requested;
             }
             if (callable instanceof IntrinsicReference) {
-                return yield* invokeIntrinsic(self.runner, 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 toProgram(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 toProgram(invokeCoercion(callable, args, node), `${callable.name} result`);
+                return yield* invokeIntrinsic(self.runtime.runner, callable, args, node);
             }
-            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 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);
         });
     }
-    invokeObjectMethodOnTools(name, ref, node) {
-        if (name === "keys") {
-            return toProgram(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* () {
@@ -1652,8 +1319,7 @@ export class Interpreter {
         });
     }
     invokeFunction(fn, args) {
-        const invocation = new Interpreter(this.executeTool, this.invokeSearch, this.toolKeys, this.promises, this.logs);
-        invocation.scopes = new ScopeStack([...fn.capturedScopes, new Map()]);
+        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.
             const paramScope = invocation.scopes.current();
@@ -1681,7 +1347,7 @@ export class Interpreter {
             return run;
         // The initial yield assigns the promise before the body can self-resolve.
         const box = {};
-        return Effect.map(this.createPromise(Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runner, value, fn.body, box))), (promise) => {
+        return Effect.map(this.createPromise(Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, box))), (promise) => {
             box.promise = promise;
             return promise;
         });
@@ -1702,7 +1368,7 @@ export class Interpreter {
                 if (state.draining)
                     return Deferred.await(request.response);
                 state.draining = true;
-                return Effect.andThen(this.promises.fork(invocation
+                return Effect.andThen(this.runtime.promises.fork(invocation
                     .completeGeneratorRequests(state, true)
                     .pipe(Effect.ensuring(Effect.sync(() => (state.draining = false))))), Deferred.await(request.response));
             }
@@ -1740,7 +1406,7 @@ export class Interpreter {
                     yield* invocation.completeGeneratorRequests(state, asynchronous);
                     state.completed = true;
                 });
-                return Effect.andThen(this.promises.fork(body), Deferred.await(request.response));
+                return Effect.andThen(this.runtime.promises.fork(body), Deferred.await(request.response));
             }
             return Deferred.await(request.response);
         });
@@ -2018,38 +1684,12 @@ export class Interpreter {
                 }
                 return new ToolReference([...objectValue.path, key]);
             }
-            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);
-            }
-            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 (objectValue instanceof HostFunction || objectValue instanceof HostNamespace) {
                 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);
+                return new ComputedValue(objectValue.member(key, propertyNode));
             }
             if (typeof objectValue === "string") {
                 if (key === "length")
@@ -2066,23 +1706,6 @@ export class Interpreter {
                     return new IntrinsicReference(objectValue, key);
                 return new ComputedValue(undefined);
             }
-            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 Values.Date) {
                 if (typeof key === "string" && dateMethods.has(key))
                     return new IntrinsicReference(objectValue, key);