@opencode/codemode 2.0.3 → 2.0.5

package/dist/interpreter/errors.js

@@ -1,18 +1,18 @@
 import { Effect } from "effect";
 import { ToolError } from "../tool-error.js";
-import { toData, ToolRuntimeError } from "../data.js";
-import { formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js";
+import { ToolRuntimeError } from "../tool-runtime.js";
+import { formatLocation, PendingThrow, Throw, sourceLocation, typeError } from "./model.js";
 import { containsRuntimeReference } from "./references.js";
 import { createErrorValue, isErrorType } from "./intrinsics.js";
 import { constructor, methods, prototypeFrom, receiver } from "./native.js";
-import { define, get, hidden, ProgramArray, ProgramError, ProgramObject, } from "./objects.js";
-import {} from "./runner.js";
+import { define, get, hidden, Arr, ErrorObj, Obj } from "./objects.js";
+import { formatValue } from "../stdlib/console.js";
 import { coerceToString } from "../stdlib/value.js";
 export const normalizeError = (error) => {
-    if (error instanceof InterpreterRuntimeError) {
+    if (error instanceof PendingThrow) {
         return {
             kind: error.kind,
-            message: `${error.message}${formatLocation(error.node)}`,
+            message: `${error.type}: ${error.message}${formatLocation(error.node)}`,
             ...(error.node?.loc ? { location: sourceLocation(error.node) } : {}),
             ...(error.suggestions ? { suggestions: error.suggestions } : {}),
         };
@@ -27,8 +27,11 @@ export const normalizeError = (error) => {
     if (error instanceof ToolError) {
         return { kind: "ToolFailure", message: error.message };
     }
-    if (error instanceof ProgramThrow) {
+    if (error instanceof Throw) {
         const value = error.value;
+        if (value instanceof ErrorObj) {
+            return value.host ? normalizeError(value.host) : { kind: "ExecutionFailure", message: errorToString(value) };
+        }
         let message;
         if (containsRuntimeReference(value)) {
             // Never expose runtime reference internals through thrown values.
@@ -37,16 +40,8 @@ export const normalizeError = (error) => {
         else if (typeof value === "string") {
             message = value;
         }
-        else if (value instanceof ProgramObject && typeof get(value, "message") === "string") {
-            message = get(value, "message");
-        }
         else {
-            try {
-                message = JSON.stringify(toData(value, "Thrown value")) ?? String(value);
-            }
-            catch {
-                message = String(value);
-            }
+            message = formatValue(value);
         }
         return { kind: "ExecutionFailure", message: `Uncaught: ${message}` };
     }
@@ -67,68 +62,85 @@ export const normalizeError = (error) => {
         message: String(error),
     };
 };
-export const caughtErrorValue = (runner, thrown) => {
-    if (thrown instanceof ProgramThrow)
+/**
+ * Gives a failure the source location of the expression that raised it, keeping the first one attached. Host errors
+ * that escape a built-in become the equivalent program error here.
+ */
+export const locate = (error, node) => {
+    if (error instanceof PendingThrow) {
+        if (error.node === undefined && node)
+            error.node = node;
+        return error;
+    }
+    if (error instanceof Error && !(error instanceof ToolError) && !(error instanceof ToolRuntimeError)) {
+        return new PendingThrow(isErrorType(error.name) ? error.name : "Error", error.message, node);
+    }
+    return error;
+};
+/** The program value a handler receives for a failure; one failure always yields the same value. */
+export const materialize = (ctx, thrown) => {
+    if (thrown instanceof Throw)
         return thrown.value;
-    const prototypes = runner.prototypes;
-    if (thrown instanceof InterpreterRuntimeError)
-        return createErrorValue(prototypes[thrown.type], thrown.message);
+    const builtins = ctx.builtins;
+    if (thrown instanceof PendingThrow) {
+        if (thrown.value === undefined) {
+            thrown.value = createErrorValue(builtins[thrown.type], thrown.message);
+            thrown.value.host = thrown;
+        }
+        return thrown.value;
+    }
     const type = thrown instanceof Error && isErrorType(thrown.name) ? thrown.name : "Error";
-    return createErrorValue(prototypes[type], normalizeError(thrown).message);
+    return createErrorValue(builtins[type], normalizeError(thrown).message);
 };
-export const createAggregateErrorValue = (runner, errors, message, proto = runner.prototypes.AggregateError) => {
+/** Error.prototype.toString: `name: message`, omitting whichever side is empty. */
+const errorToString = (self) => {
+    const name = get(self, "name");
+    const message = get(self, "message");
+    const shownName = name === undefined ? "Error" : coerceToString(name);
+    const shownMessage = message === undefined ? "" : coerceToString(message);
+    if (shownMessage === "")
+        return shownName;
+    if (shownName === "")
+        return shownMessage;
+    return `${shownName}: ${shownMessage}`;
+};
+export const createAggregateErrorValue = (ctx, errors, message, proto = ctx.builtins.AggregateError) => {
     const value = createErrorValue(proto, message);
-    define(value, "errors", new ProgramArray(runner.prototypes.Array, errors), { ...hidden });
+    define(value, "errors", new Arr(ctx.builtins.Array, errors), { ...hidden });
     return value;
 };
-const constructAggregateErrorValue = (runner, args, proto, node) => Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(args[0], node);
-    if (cursor === undefined) {
-        throw new InterpreterRuntimeError("new AggregateError(...) expects a synchronous iterable of errors.", node);
-    }
+const constructAggregateErrorValue = (ctx, args, proto) => Effect.gen(function* () {
+    const cursor = yield* ctx.iterate(args[0]);
+    if (cursor === undefined)
+        throw typeError("new AggregateError(...) expects a synchronous iterable of errors.");
     const errors = [];
     while (true) {
         const step = yield* cursor.next;
         if (step.done) {
-            return createAggregateErrorValue(runner, errors, args[1] === undefined ? "" : coerceToString(args[1]), proto);
+            return createAggregateErrorValue(ctx, errors, args[1] === undefined ? "" : coerceToString(args[1]), proto);
         }
         errors.push(step.value);
     }
 });
 /** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
-export const errorGlobal = (type, runner) => {
-    const protos = runner.prototypes;
-    const prototype = protos[type];
-    const construct = (args, newTarget, node) => {
+export const errorGlobal = (type, ctx) => {
+    const builtins = ctx.builtins;
+    const prototype = builtins[type];
+    const construct = (args, newTarget) => {
         const proto = prototypeFrom(newTarget, prototype);
         return type === "AggregateError"
-            ? constructAggregateErrorValue(runner, args, proto, node)
+            ? constructAggregateErrorValue(ctx, args, proto)
             : Effect.sync(() => createErrorValue(proto, args[0] === undefined ? undefined : coerceToString(args[0])));
     };
-    const ctor = constructor(protos, prototype, {
+    const ctor = constructor(builtins, prototype, {
         name: type,
         length: type === "AggregateError" ? 2 : 1,
-        call: (_, args, node) => construct(args, ctor, node),
+        call: (_, args) => construct(args, ctor),
         construct,
     });
     if (type === "Error") {
-        methods(protos, prototype, [
-            [
-                "toString",
-                0,
-                (thisValue, _, node) => {
-                    const self = receiver(ProgramObject, thisValue, "Error.prototype.toString", node);
-                    const name = get(self, "name");
-                    const message = get(self, "message");
-                    const shownName = name === undefined ? "Error" : coerceToString(name);
-                    const shownMessage = message === undefined ? "" : coerceToString(message);
-                    if (shownMessage === "")
-                        return shownName;
-                    if (shownName === "")
-                        return shownMessage;
-                    return `${shownName}: ${shownMessage}`;
-                },
-            ],
+        methods(builtins, prototype, [
+            ["toString", 0, (thisValue) => errorToString(receiver(Obj, thisValue, "Error.prototype.toString"))],
         ]);
     }
     return ctor;

package/dist/interpreter/execute.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
 import type { ResolvedExecutionLimits, Result } from "../codemode.js";
 import { ToolRuntime } from "../tool-runtime.js";
-import type { Host } from "./globals.js";
-export declare const executeProgram: <R>(code: string, prepared: ToolRuntime.Prepared<R>, limits: ResolvedExecutionLimits, hooks: ToolRuntime.ToolCallHooks<R>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>) => Effect.Effect<Result, never, R>;
+import { Interpreter } from "./interpreter.js";
+export declare const executeProgram: <R>(code: string, prepared: ToolRuntime.Prepared<R>, limits: ResolvedExecutionLimits, hooks: ToolRuntime.Hooks<R>, globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>) => Effect.Effect<Result, never, R>;

package/dist/interpreter/execute.js

@@ -3,14 +3,14 @@ import { Cause, Effect, Scope } from "effect";
 // #transpile: conditional import — full typescript on node/bun, an identity
 // pass-through on workerd (the compiler is ~11 MiB and can't init there).
 import { transpile } from "#transpile";
-import { toData } from "../data.js";
+import { toBoundary } from "../data.js";
 import { ToolRuntime } from "../tool-runtime.js";
 import { normalizeError } from "./errors.js";
-import { createPrototypes } from "./intrinsics.js";
-import { InterpreterRuntimeError } from "./model.js";
-import { PromiseRuntime } from "./promises.js";
-import { Runtime } from "./runtime.js";
-export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
+import { createBuiltins } from "./intrinsics.js";
+import { PendingThrow } from "./model.js";
+import { Pending } from "./promises.js";
+import { Interpreter } from "./interpreter.js";
+export const executeProgram = (code, prepared, limits, hooks, globals) => {
     if (code.trim().length === 0) {
         return Effect.succeed({
             ok: false,
@@ -20,19 +20,19 @@ export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
     }
     // Allocate execution state inside suspension so reused Effects never share it.
     return Effect.suspend(() => {
-        const prototypes = createPrototypes();
-        const tools = ToolRuntime.make(prepared, prototypes, limits.maxToolCalls, hooks);
+        const builtins = createBuiltins();
+        const tools = ToolRuntime.make(prepared, limits.maxToolCalls, hooks);
         const logs = [];
         const logged = () => (logs.length > 0 ? { logs: [...logs] } : {});
         // Set only after copy-out so timeouts cannot report invalid values as completed.
         let returned;
         const base = Effect.acquireUseRelease(Scope.make("parallel"), (scope) => Effect.gen(function* () {
             const program = parseProgram(code);
-            const promises = new PromiseRuntime(scope, prototypes.Promise);
-            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, prototypes, logs, extraGlobals).run(program);
-            const result = toData(value, "Execution result", "result");
-            returned = { value: result, promises };
-            const warnings = yield* promises.interrupt();
+            const pending = new Pending(scope, builtins.Promise);
+            const ctx = new Interpreter({ tools, pending, builtins, logs, globals });
+            const result = (yield* toBoundary(ctx, yield* ctx.run(program))) ?? null;
+            returned = { value: result, pending };
+            const warnings = yield* pending.interrupt();
             return {
                 ok: true,
                 value: result,
@@ -64,7 +64,7 @@ export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
                                 kind: "TimeoutExceeded",
                                 message: `The program returned, but background work was still running at the ${timeoutMs}ms timeout and was interrupted. Await all started promises.`,
                             },
-                            ...returned.promises.diagnostics(),
+                            ...returned.pending.diagnostics(),
                         ],
                         ...logged(),
                         toolCalls: tools.calls,
@@ -84,7 +84,7 @@ export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
 const parseProgram = (code) => {
     const transpiled = transpile(`async function __codemode__() {\n${code}\n}`);
     if (transpiled.error !== undefined) {
-        throw new InterpreterRuntimeError(`Failed to parse TypeScript: ${transpiled.error}`, undefined, "ParseError");
+        throw new PendingThrow("SyntaxError", `Failed to parse TypeScript: ${transpiled.error}`, undefined, "ParseError");
     }
     const bodyStart = transpiled.outputText.indexOf("{") + 1;
     const bodyEnd = transpiled.outputText.lastIndexOf("}");

package/dist/interpreter/extensions.d.ts

@@ -0,0 +1,8 @@
+import type { Extension } from "../extension.js";
+import type { Interpreter } from "./interpreter.js";
+/**
+ * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data and
+ * built-in wrappers are copied, a host function becomes a program function whose calls cross the same way, and a
+ * host Promise becomes a program promise.
+ */
+export declare const extensionGlobals: <R>(ctx: Interpreter<R>, extensions: ReadonlyArray<Extension>) => ReadonlyArray<readonly [string, unknown]>;

package/dist/interpreter/extensions.js

@@ -0,0 +1,160 @@
+import { Effect } from "effect";
+import { coerceToString } from "../stdlib/value.js";
+import { hooked } from "../tool-runtime.js";
+import { createErrorValue, isErrorType } from "./intrinsics.js";
+import { MAX_VALUE_DEPTH } from "./limits.js";
+import { Throw, typeError } from "./model.js";
+import { fn } from "./native.js";
+import { Callable, define, entries, get, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./objects.js";
+import { describeValue } from "./references.js";
+/**
+ * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data and
+ * built-in wrappers are copied, a host function becomes a program function whose calls cross the same way, and a
+ * host Promise becomes a program promise.
+ */
+export const extensionGlobals = (ctx, extensions) => {
+    const builtins = ctx.builtins;
+    const toHost = (value, label, depth = 0, seen = new Set()) => {
+        if (depth > MAX_VALUE_DEPTH)
+            throw typeError(`${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
+        if (value === null || typeof value !== "object") {
+            if (isPrimitive(value))
+                return value;
+            throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
+        }
+        if (value instanceof Bytes)
+            return new Uint8Array(value.bytes);
+        if (value instanceof DateObj)
+            return new Date(value.time);
+        if (value instanceof RegExpObj)
+            return new RegExp(value.regex.source, value.regex.flags);
+        if (value instanceof URLObj)
+            return new URL(value.url.href);
+        if (value instanceof URLSearchParamsObj)
+            return new URLSearchParams(value.params);
+        const next = (item) => toHost(item, label, depth + 1, seen);
+        if (value instanceof MapObj)
+            return new Map([...value.map].map(([key, item]) => [next(key), next(item)]));
+        if (value instanceof SetObj)
+            return new Set([...value.set].map(next));
+        if (!(value instanceof Obj) ||
+            value instanceof Callable ||
+            value instanceof GeneratorObj ||
+            value instanceof PromiseObj) {
+            throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
+        }
+        if (value instanceof ErrorObj) {
+            const name = coerceToString(get(value, "name"));
+            const message = get(value, "message");
+            const text = message === undefined ? "" : coerceToString(message);
+            return name === "AggregateError" ? new AggregateError([], text) : new (hostErrors.get(name) ?? Error)(text);
+        }
+        if (seen.has(value))
+            throw typeError(`${label} contains a circular value.`);
+        seen.add(value);
+        const copied = value instanceof Arr
+            ? value.items.map(next)
+            : Object.fromEntries(entries(value)
+                .filter(([key]) => key !== "__proto__")
+                .map(([key, item]) => [key, next(item)]));
+        seen.delete(value);
+        return copied;
+    };
+    const fromHost = (value, label, depth = 0, seen = new Set()) => {
+        if (depth > MAX_VALUE_DEPTH)
+            throw typeError(`${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
+        if (isPrimitive(value))
+            return value;
+        if (typeof value === "function")
+            return wrap(value, label);
+        if (value !== null && typeof value === "object") {
+            if (value instanceof Date)
+                return new DateObj(builtins.Date, value.getTime());
+            if (value instanceof RegExp)
+                return new RegExpObj(builtins.RegExp, value.source, value.flags);
+            if (value instanceof Uint8Array)
+                return new Bytes(builtins.Uint8Array, new Uint8Array(value));
+            if (value instanceof ArrayBuffer)
+                return new Bytes(builtins.Uint8Array, new Uint8Array(value.slice(0)));
+            if (value instanceof Error) {
+                return createErrorValue(builtins[isErrorType(value.name) ? value.name : "Error"], value.message);
+            }
+            if (value instanceof URL)
+                return new URLObj(builtins.URL, builtins.URLSearchParams, new URL(value.href));
+            if (value instanceof URLSearchParams) {
+                return new URLSearchParamsObj(builtins.URLSearchParams, new URLSearchParams(value));
+            }
+            const next = (item, path) => fromHost(item, path, depth + 1, seen);
+            if (value instanceof Map) {
+                const wrapped = new MapObj(builtins.Map);
+                for (const [key, item] of value)
+                    wrapped.map.set(next(key, label), next(item, label));
+                return wrapped;
+            }
+            if (value instanceof Set) {
+                const wrapped = new SetObj(builtins.Set);
+                for (const item of value)
+                    wrapped.set.add(next(item, label));
+                return wrapped;
+            }
+            if (seen.has(value))
+                throw typeError(`${label} produced a circular value.`);
+            seen.add(value);
+            if (Array.isArray(value)) {
+                const copied = new Arr(builtins.Array, value.map((item, index) => next(item, `${label}[${index}]`)));
+                seen.delete(value);
+                return copied;
+            }
+            const prototype = Object.getPrototypeOf(value);
+            if (prototype === Object.prototype || prototype === null) {
+                const copied = new Obj(builtins.Object);
+                for (const [key, item] of Object.entries(value))
+                    define(copied, key, next(item, `${label}.${key}`));
+                seen.delete(value);
+                return copied;
+            }
+        }
+        throw typeError(`${label} produced ${describeHost(value)}, which the program cannot hold.`);
+    };
+    // A host function as a program function. Arguments cross in; a global's call runs inside the host's extension
+    // hooks, which see the host's own error on failure; then whatever came back, or was thrown, crosses out so the
+    // program catches a copy. Functions inside results are part of a value's API and skip the hooks.
+    const wrap = (value, label, describe) => fn(builtins, value.name, value.length, (_, values) => {
+        const args = values.map((item, index) => toHost(item, `Argument ${index + 1} to ${label}`));
+        const hooks = ctx.tools.hooks;
+        const settle = (run) => (describe === undefined
+            ? run
+            : hooked(describe(args), hooks["extension.before"], hooks["extension.after"], run)).pipe(Effect.mapError((reason) => new Throw(fromHost(reason, label))), Effect.map((settled) => fromHost(settled, label)));
+        let result;
+        try {
+            result = value.apply(undefined, args);
+        }
+        catch (reason) {
+            return settle(Effect.fail(reason));
+        }
+        if (!(result instanceof Promise))
+            return settle(Effect.succeed(result));
+        return ctx.pending.create(settle(Effect.tryPromise({ try: () => result, catch: (reason) => reason })));
+    });
+    return extensions.flatMap((extension) => Object.entries(extension.globals).map(([name, value]) => [name, wrap(value, name, (args) => ({ extension: extension.name, name, args }))]));
+};
+const hostErrors = new Map([
+    ["TypeError", TypeError],
+    ["RangeError", RangeError],
+    ["SyntaxError", SyntaxError],
+    ["ReferenceError", ReferenceError],
+    ["EvalError", EvalError],
+    ["URIError", URIError],
+]);
+// The primitives the interpreter operates on; symbols and BigInts are not among them.
+const isPrimitive = (value) => value === null ||
+    value === undefined ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean";
+const describeHost = (value) => {
+    if (typeof value !== "object" || value === null)
+        return `a ${typeof value}`;
+    const name = value.constructor?.name;
+    return name === undefined || name === "" ? "an object" : `a ${name}`;
+};

package/dist/interpreter/generators.d.ts

@@ -1,4 +1,3 @@
-import type { PromiseRuntime } from "./promises.js";
-import type { Runner } from "./runner.js";
+import type { Interpreter } from "./interpreter.js";
 /** `next`/`return`/`throw` on the generator prototypes; async generators answer with promises. */
-export declare const generatorGlobals: <R>(runner: Runner<R>, promises: PromiseRuntime<R>) => void;
+export declare const generatorGlobals: <R>(ctx: Interpreter<R>) => void;

package/dist/interpreter/generators.js

@@ -1,24 +1,24 @@
 import { Effect } from "effect";
 import { fn, methods, receiver } from "./native.js";
 import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
-import { define, hidden, ProgramGenerator } from "./objects.js";
+import { define, hidden, GeneratorObj } from "./objects.js";
 /** `next`/`return`/`throw` on the generator prototypes; async generators answer with promises. */
-export const generatorGlobals = (runner, promises) => {
-    const protos = runner.prototypes;
+export const generatorGlobals = (ctx) => {
+    const builtins = ctx.builtins;
     const install = (asynchronous) => {
-        const proto = asynchronous ? protos.AsyncGenerator : protos.Generator;
+        const proto = asynchronous ? builtins.AsyncGenerator : builtins.Generator;
         const label = asynchronous ? "AsyncGenerator" : "Generator";
         const request = (kind) => [
             kind,
             1,
-            (thisValue, args, node) => {
-                const generator = receiver(ProgramGenerator, thisValue, `${label}.prototype.${kind}`, node);
-                const requested = generator.request(kind, args[0], node);
-                return generator.asynchronous ? promises.create(requested) : requested;
+            (thisValue, args) => {
+                const generator = receiver(GeneratorObj, thisValue, `${label}.prototype.${kind}`);
+                const requested = generator.request(kind, args[0]);
+                return generator.asynchronous ? ctx.pending.create(requested) : requested;
             },
         ];
-        methods(protos, proto, [request("next"), request("return"), request("throw")]);
-        define(asynchronous ? protos.AsyncIterator : protos.Iterator, asynchronous ? AsyncIteratorSymbol : IteratorSymbol, fn(protos, asynchronous ? "[Symbol.asyncIterator]" : "[Symbol.iterator]", 0, (thisValue) => thisValue), hidden);
+        methods(builtins, proto, [request("next"), request("return"), request("throw")]);
+        define(asynchronous ? builtins.AsyncIterator : builtins.Iterator, asynchronous ? AsyncIteratorSymbol : IteratorSymbol, fn(builtins, asynchronous ? "[Symbol.asyncIterator]" : "[Symbol.iterator]", 0, (thisValue) => thisValue), hidden);
     };
     install(false);
     install(true);

package/dist/interpreter/globals.d.ts

@@ -1,13 +1,5 @@
-import { Effect } from "effect";
-import { type PromiseRuntime } from "./promises.js";
-import type { Runner } from "./runner.js";
-/** What the built-in globals need from the interpreter that owns them. */
-export type Host<R> = {
-    readonly runner: Runner<R>;
-    readonly promises: PromiseRuntime<R>;
-    readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
-    readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
-    readonly logs: Array<string>;
-};
+import type { Interpreter } from "./interpreter.js";
+/** Names bound in every program before extensions apply. */
+export declare const globalNames: ReadonlySet<string>;
 /** The immutable global bindings of every program, in declaration order. */
-export declare const globals: <R>(host: Host<R>) => ReadonlyArray<readonly [string, unknown]>;
+export declare const globals: <R>(ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>;

package/dist/interpreter/globals.js

@@ -1,5 +1,6 @@
 import { Effect } from "effect";
 import { arrayGlobal } from "../stdlib/array.js";
+import { textDecoderGlobal, textEncoderGlobal, uint8ArrayGlobal } from "../stdlib/bytes.js";
 import { mapGlobal, setGlobal } from "../stdlib/collections.js";
 import { consoleGlobal } from "../stdlib/console.js";
 import { dateGlobal } from "../stdlib/date.js";
@@ -16,70 +17,76 @@ import { ToolReference } from "../tool-runtime.js";
 import { errorGlobal } from "./errors.js";
 import { errorTypes } from "./intrinsics.js";
 import { constants, constructor, native } from "./native.js";
-import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "./model.js";
+import { AsyncIteratorSymbol, IteratorSymbol, typeError } from "./model.js";
 import { generatorGlobals } from "./generators.js";
 import { promiseGlobal } from "./promises.js";
 // Function.prototype.constructor exists so `fn.constructor === Function` holds; dynamic code is unsupported.
-const functionGlobal = (runner) => {
-    const reject = (_, __, node) => Effect.sync(() => {
-        throw new InterpreterRuntimeError("The Function constructor is not supported; write the function inline.", node);
+const functionGlobal = (ctx) => {
+    const reject = () => Effect.sync(() => {
+        throw typeError("The Function constructor is not supported; write the function inline.");
     });
-    return constructor(runner.prototypes, runner.prototypes.Function, {
+    return constructor(ctx.builtins, ctx.builtins.Function, {
         name: "Function",
         length: 1,
         call: reject,
-        construct: (args, _, node) => reject(undefined, args, node),
+        construct: reject,
     });
 };
-const symbolGlobal = (runner) => {
-    const symbol = native(runner.prototypes, {
+const symbolGlobal = (ctx) => {
+    const symbol = native(ctx.builtins, {
         name: "Symbol",
-        call: (_, __, node) => Effect.sync(() => {
-            throw new InterpreterRuntimeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.", node);
+        call: () => Effect.sync(() => {
+            throw typeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.");
         }),
         callback: false,
     });
     constants(symbol, { asyncIterator: AsyncIteratorSymbol, iterator: IteratorSymbol });
     return symbol;
 };
+// A table rather than a list so the names are known before any runtime exists.
+const table = {
+    tools: () => new ToolReference([]),
+    search: (ctx) => native(ctx.builtins, { name: "search", call: (_, args) => ctx.tool(ctx.tools.search, args), callback: false }),
+    undefined: () => undefined,
+    NaN: () => NaN,
+    Infinity: () => Infinity,
+    Object: (ctx) => objectGlobal(ctx),
+    Function: (ctx) => functionGlobal(ctx),
+    Array: (ctx) => arrayGlobal(ctx),
+    Math: (ctx) => mathGlobal(ctx),
+    JSON: (ctx) => jsonGlobal(ctx),
+    console: (ctx) => consoleGlobal(ctx),
+    Promise: (ctx) => promiseGlobal(ctx),
+    Symbol: (ctx) => symbolGlobal(ctx),
+    Number: (ctx) => numberGlobal(ctx),
+    String: (ctx) => stringGlobal(ctx),
+    Boolean: (ctx) => booleanGlobal(ctx),
+    parseInt: (ctx) => coercion(ctx, "parseInt", 2),
+    parseFloat: (ctx) => coercion(ctx, "parseFloat"),
+    isFinite: (ctx) => coercion(ctx, "isFinite"),
+    isNaN: (ctx) => coercion(ctx, "isNaN"),
+    Date: (ctx) => dateGlobal(ctx),
+    RegExp: (ctx) => regexpGlobal(ctx),
+    Map: (ctx) => mapGlobal(ctx),
+    Set: (ctx) => setGlobal(ctx),
+    URL: (ctx) => urlGlobal(ctx),
+    URLSearchParams: (ctx) => urlSearchParamsGlobal(ctx),
+    Uint8Array: (ctx) => uint8ArrayGlobal(ctx),
+    TextEncoder: (ctx) => textEncoderGlobal(ctx),
+    TextDecoder: (ctx) => textDecoderGlobal(ctx),
+    encodeURI: (ctx) => uriGlobal(ctx, "encodeURI"),
+    encodeURIComponent: (ctx) => uriGlobal(ctx, "encodeURIComponent"),
+    decodeURI: (ctx) => uriGlobal(ctx, "decodeURI"),
+    decodeURIComponent: (ctx) => uriGlobal(ctx, "decodeURIComponent"),
+    atob: (ctx) => base64Global(ctx, "atob"),
+    btoa: (ctx) => base64Global(ctx, "btoa"),
+    crypto: (ctx) => cryptoGlobal(ctx),
+    ...Object.fromEntries(errorTypes.map((type) => [type, (ctx) => errorGlobal(type, ctx)])),
+};
+/** Names bound in every program before extensions apply. */
+export const globalNames = new Set(Object.keys(table));
 /** The immutable global bindings of every program, in declaration order. */
-export const globals = (host) => {
-    const runner = host.runner;
-    generatorGlobals(runner, host.promises);
-    return [
-        ["tools", new ToolReference([])],
-        ["search", native(runner.prototypes, { name: "search", call: (_, args) => host.search(args), callback: false })],
-        ["undefined", undefined],
-        ["NaN", NaN],
-        ["Infinity", Infinity],
-        ["Object", objectGlobal(runner, host.toolKeys)],
-        ["Function", functionGlobal(runner)],
-        ["Array", arrayGlobal(runner)],
-        ["Math", mathGlobal(runner)],
-        ["JSON", jsonGlobal(runner)],
-        ["console", consoleGlobal(runner, host.logs)],
-        ["Promise", promiseGlobal(runner, host.promises)],
-        ["Symbol", symbolGlobal(runner)],
-        ["Number", numberGlobal(runner)],
-        ["String", stringGlobal(runner)],
-        ["Boolean", booleanGlobal(runner)],
-        ["parseInt", coercion(runner, "parseInt", 2)],
-        ["parseFloat", coercion(runner, "parseFloat")],
-        ["isFinite", coercion(runner, "isFinite")],
-        ["isNaN", coercion(runner, "isNaN")],
-        ["Date", dateGlobal(runner)],
-        ["RegExp", regexpGlobal(runner)],
-        ["Map", mapGlobal(runner)],
-        ["Set", setGlobal(runner)],
-        ["URL", urlGlobal(runner)],
-        ["URLSearchParams", urlSearchParamsGlobal(runner)],
-        ["encodeURI", uriGlobal(runner, "encodeURI")],
-        ["encodeURIComponent", uriGlobal(runner, "encodeURIComponent")],
-        ["decodeURI", uriGlobal(runner, "decodeURI")],
-        ["decodeURIComponent", uriGlobal(runner, "decodeURIComponent")],
-        ["atob", base64Global(runner, "atob")],
-        ["btoa", base64Global(runner, "btoa")],
-        ["crypto", cryptoGlobal(runner)],
-        ...errorTypes.map((type) => [type, errorGlobal(type, runner)]),
-    ];
+export const globals = (ctx) => {
+    generatorGlobals(ctx);
+    return Object.entries(table).map(([name, factory]) => [name, factory(ctx)]);
 };