@opencode/codemode 2.0.3 → 2.0.5

package/dist/interpreter/{runtime.js → interpreter.js}

@@ -1,12 +1,13 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
-import { toProgram } from "../data.js";
+import { fromJson, toBoundary } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
-import { AsyncIteratorSymbol, GeneratorReturn, InterpreterRuntimeError, IteratorSymbol, locate, OptionalShortCircuit, ProgramThrow, rangeError, unsupportedSyntax, } from "./model.js";
-import { caughtErrorValue } from "./errors.js";
+import { AsyncIteratorSymbol, CallSite, GeneratorReturn, IteratorSymbol, OptionalShortCircuit, invalidData, Throw, rangeError, typeError, unsupportedSyntax, } from "./model.js";
+import { checkStringLength } from "./limits.js";
+import { locate, materialize } 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 { preserveConsumerError } from "./runner.js";
-import { PromiseRuntime, resolvePromise, resolvePromiseValue } from "./promises.js";
+import { assign, Callable, define, get, has, hasPrototype, keys, Native, parseArrayIndex, Arr, Bytes, DateObj, Fn, GeneratorObj, MapObj, Obj, PromiseObj, SetObj, URLSearchParamsObj, record, remove, set, } from "./objects.js";
+import { preserveConsumerError } from "./callback.js";
+import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
 import { ScopeStack } from "./scope.js";
 import { constructRegExp } from "../stdlib/regexp.js";
@@ -45,11 +46,11 @@ const calleeDescription = (callee) => {
 // OrdinaryHasInstance: walk the left operand's chain looking for the constructor's `prototype`.
 const instanceofValue = (lhs, rhs, node) => {
     if (!(rhs instanceof Callable)) {
-        throw new InterpreterRuntimeError("The right-hand side of 'instanceof' is not callable.", node);
+        throw typeError("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);
+    if (!(prototype instanceof Obj)) {
+        throw typeError("The right-hand side of 'instanceof' has no 'prototype' object.", node);
     }
     return hasPrototype(lhs, prototype);
 };
@@ -132,7 +133,7 @@ const loopDeclaration = (left, statement) => {
         return undefined;
     const declaration = left.declarations.length === 1 ? left.declarations[0] : undefined;
     if (declaration === undefined) {
-        throw new InterpreterRuntimeError(`${statement} supports one declared binding.`, left);
+        throw typeError(`${statement} supports one declared binding.`, left);
     }
     const kind = left.kind;
     return {
@@ -141,50 +142,60 @@ const loopDeclaration = (left, statement) => {
         lexical: kind !== "var",
     };
 };
-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 {
-    executeTool;
-    search;
-    toolKeys;
-    promises;
-    prototypes;
+export class Interpreter {
+    tools;
+    pending;
+    builtins;
     logs;
-    runner;
     root;
-    constructor(executeTool, search, toolKeys, promises, prototypes, logs = [], extraGlobals = () => []) {
-        this.executeTool = executeTool;
-        this.search = search;
-        this.toolKeys = toolKeys;
-        this.promises = promises;
-        this.prototypes = prototypes;
-        this.logs = logs;
+    constructor(options) {
+        this.tools = options.tools;
+        this.pending = options.pending;
+        this.builtins = options.builtins;
+        this.logs = options.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),
-            settlePromise: (promise) => this.root.settlePromise(promise),
-            syncIterator: (value, node) => this.root.syncIterator(value, node),
-            prototypes,
-        };
-        for (const [name, value] of [...globals(this), ...extraGlobals(this)]) {
+        for (const [name, value] of [...globals(this), ...(options.globals?.(this) ?? [])]) {
             globalScope.set(name, { mutable: false, value });
         }
     }
     run(program) {
         return this.root.run(program);
     }
+    call(callable, thisValue, args) {
+        return this.root.call(callable, thisValue, args);
+    }
+    await(promise) {
+        return this.root.await(promise);
+    }
+    iterate(value) {
+        return this.root.iterate(value);
+    }
+    /** Runs one host tool: arguments cross as JSON and the result comes back as program values. */
+    tool(run, args) {
+        const ctx = this;
+        return Effect.gen(function* () {
+            const json = yield* Effect.forEach(args, (arg) => toBoundary(ctx, arg));
+            return fromJson(ctx, yield* run(json));
+        });
+    }
 }
+const MAX_CALL_DEPTH = 10_000;
 /** One activation: the top-level program or a single function call, evaluating against its own scope chain. */
 class Frame {
-    runtime;
+    ctx;
     scopes;
+    depth;
     generatorState;
     generatorAsync = false;
-    constructor(runtime, scopes) {
-        this.runtime = runtime;
+    constructor(ctx, scopes, 
+    /** Nested call depth; resets when an await resumes, since the continuation runs from the job queue. */
+    depth = 0) {
+        this.ctx = ctx;
         this.scopes = scopes;
+        this.depth = depth;
     }
     run(program) {
         const self = this;
@@ -206,24 +217,24 @@ class Frame {
                     break;
                 }
                 if (result.kind === "break" || result.kind === "continue") {
-                    throw new InterpreterRuntimeError(`Unexpected '${result.kind}' outside of a loop.`, statement);
+                    throw typeError(`Unexpected '${result.kind}' outside of a loop.`, statement);
                 }
             }
             // The implicit async body adopts returned promises before copy-out.
-            value = yield* resolvePromiseValue(self.runtime.runner, value, program);
+            value = yield* resolvePromiseValue(self.ctx, value);
             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.runtime.promises.create(Effect.suspend(() => this.runtime.executeTool(path, args)));
+        return this.ctx.pending.create(this.ctx.tool((json) => this.ctx.tools.execute(path, json), args));
     }
     // Fiber exits make settlement idempotent; yielding prevents inline continuation.
-    settlePromise(promise) {
-        const promises = this.runtime.promises;
+    await(promise) {
+        const pending = this.ctx.pending;
         return Effect.suspend(() => {
-            promises.markObserved(promise);
-            return Effect.flatMap(promises.await(promise), (exit) => Effect.andThen(Effect.yieldNow, exit));
+            pending.markObserved(promise);
+            return Effect.flatMap(pending.await(promise), (exit) => Effect.andThen(Effect.yieldNow, exit));
         });
     }
     evaluateStatement(node) {
@@ -289,7 +300,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 Fn(this.ctx.builtins.Function, 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) {
@@ -348,7 +359,7 @@ class Frame {
         return Effect.gen(function* () {
             const discriminant = yield* self.evaluateExpression(node.discriminant);
             if (containsOpaqueReference(discriminant)) {
-                throw new InterpreterRuntimeError("Switch discriminants must be data values.", node, "InvalidDataValue");
+                throw invalidData("Switch discriminants must be data values.", node);
             }
             self.scopes.push();
             return yield* Effect.gen(function* () {
@@ -366,7 +377,7 @@ class Frame {
                     }
                     const candidate = yield* self.evaluateExpression(test);
                     if (containsOpaqueReference(candidate)) {
-                        throw new InterpreterRuntimeError("Switch case values must be data values.", test, "InvalidDataValue");
+                        throw invalidData("Switch case values must be data values.", test);
                     }
                     if (candidate === discriminant) {
                         selected = index;
@@ -467,9 +478,9 @@ class Frame {
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
             const right = yield* self.evaluateExpression(node.right);
             const iterator = yield* self.customIterator(right, node, awaiting);
-            const cursor = iterator === undefined ? yield* self.syncIterator(right, node) : undefined;
+            const cursor = iterator === undefined ? yield* self.iterate(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 invalidData(`${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, or URLSearchParams, or custom iterator value.`, node);
             }
             const close = () => iterator
                 ? self.closeIterator(iterator, node, awaiting)
@@ -477,7 +488,7 @@ class Frame {
                     ? Effect.andThen(cursor?.close ?? Effect.void, Effect.yieldNow)
                     : (cursor?.close ?? Effect.void);
             if (left.type === "RestElement" || left.type === "AssignmentPattern") {
-                throw new InterpreterRuntimeError("Unsupported for...of binding.", left);
+                throw typeError("Unsupported for...of binding.", left);
             }
             const assignment = left.type === "VariableDeclaration" ? undefined : left;
             const evaluateBody = (value) => Effect.gen(function* () {
@@ -500,7 +511,7 @@ class Frame {
             while (true) {
                 const current = iterator
                     ? yield* self.nextIteratorResult(iterator, node, awaiting)
-                    : yield* cursor?.next ?? Effect.fail(new InterpreterRuntimeError("Iterator is unavailable.", node));
+                    : yield* cursor?.next ?? Effect.die(typeError("Iterator is unavailable.", node));
                 const step = cursor && awaiting ? { done: current.done, value: yield* self.awaitValue(current.value) } : current;
                 if (step.done)
                     return { kind: "none" };
@@ -523,8 +534,8 @@ class Frame {
                 self.scopes.pop();
         })));
     }
-    awaitValue(value, node = promiseResolutionNode) {
-        return Effect.flatMap(resolvePromise(this.runtime.runner, this.runtime.promises, value, node), (promise) => this.settlePromise(promise));
+    awaitValue(value) {
+        return Effect.flatMap(resolvePromise(this.ctx, value), (promise) => Effect.ensuring(this.await(promise), Effect.sync(() => (this.depth = 0))));
     }
     awaitAsyncFromSyncValue(iterator, value, node, closeOnRejection) {
         const self = this;
@@ -538,26 +549,28 @@ class Frame {
             return yield* Effect.failCause(settled.cause);
         });
     }
-    syncIterator(value, node) {
-        const iterator = value instanceof ProgramArray
+    iterate(value, node) {
+        const iterator = value instanceof Arr
             ? value.items[Symbol.iterator]()
             : typeof value === "string"
                 ? value[Symbol.iterator]()
-                : value instanceof ProgramMap
+                : value instanceof MapObj
                     ? value.map.entries()
-                    : value instanceof ProgramSet
+                    : value instanceof SetObj
                         ? value.set.values()
-                        : value instanceof ProgramURLSearchParams
+                        : value instanceof URLSearchParamsObj
                             ? value.params.entries()
-                            : undefined;
+                            : value instanceof Bytes
+                                ? value.bytes.values()
+                                : undefined;
         if (iterator !== undefined) {
-            const proto = this.runtime.prototypes.Array;
+            const proto = this.ctx.builtins.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 Arr(proto, step.value) : step.value,
                     };
                 }),
                 close: Effect.void,
@@ -572,14 +585,14 @@ class Frame {
             });
     }
     customIterator(value, node, allowAsync = true) {
-        if (!(value instanceof ProgramObject))
+        if (!(value instanceof Obj))
             return Effect.undefined;
         const asyncMethod = allowAsync ? get(value, AsyncIteratorSymbol) : undefined;
         const method = asyncMethod ?? get(value, IteratorSymbol);
         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) => {
+        return Effect.map(this.call(this.requireIteratorMethod(method, "Iterator method", node), value, [], node), (iterator) => {
             const object = self.requireIteratorObject(iterator, "Iterator method result", node);
             return {
                 iterator: object,
@@ -592,10 +605,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.call(iterator.next, iterator.iterator, [], 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.call(iterator.next, iterator.iterator, [], node));
             if (!Exit.isSuccess(called)) {
                 if (awaiting)
                     yield* Effect.yieldNow;
@@ -626,10 +639,10 @@ class Frame {
         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.call(method, iterator.iterator, [], node)), "Iterator return() result", node);
                 return;
             }
-            const called = yield* Effect.exit(self.invokeCallable(method, iterator.iterator, [], node));
+            const called = yield* Effect.exit(self.call(method, iterator.iterator, [], node));
             if (!Exit.isSuccess(called)) {
                 if (awaiting)
                     yield* Effect.yieldNow;
@@ -646,22 +659,22 @@ class Frame {
         });
     }
     requireIteratorObject(value, context, node) {
-        if (value instanceof ProgramObject)
+        if (value instanceof Obj)
             return value;
-        throw new InterpreterRuntimeError(`${context} must be an object.`, node);
+        throw typeError(`${context} must be an object.`, node);
     }
     requireIteratorMethod(value, context, node) {
         if (typeofValue(value) === "function")
             return value;
-        throw new InterpreterRuntimeError(`${context} must be a function.`, node);
+        throw typeError(`${context} must be a function.`, node);
     }
     // for...in over null/undefined iterates nothing, like JS.
     enumerableKeys(value, node) {
         if (value instanceof ToolReference)
-            return [...this.runtime.toolKeys(value.path)];
+            return [...this.ctx.tools.keys(value.path)];
         if (value === null || value === undefined)
             return [];
-        return keys(enumerableSource(this.runtime.runner, "for...in", value, node));
+        return keys(enumerableSource(this.ctx, "for...in", value, node));
     }
     evaluateForInStatement(node, labels) {
         const left = node.left;
@@ -675,7 +688,7 @@ class Frame {
             const right = yield* self.evaluateExpression(node.right);
             const keys = self.enumerableKeys(right, node.right);
             if (left.type !== "Identifier" && left.type !== "VariableDeclaration") {
-                throw new InterpreterRuntimeError("Unsupported for...in binding.", left);
+                throw typeError("Unsupported for...in binding.", left);
             }
             const assignmentName = left.type === "Identifier" ? left.name : undefined;
             for (const key of keys) {
@@ -737,7 +750,7 @@ class Frame {
             : result);
     }
     evaluateThrowStatement(node) {
-        return Effect.flatMap(this.evaluateExpression(node.argument), (value) => Effect.fail(new ProgramThrow(value)));
+        return Effect.flatMap(this.evaluateExpression(node.argument), (value) => Effect.fail(new Throw(value)));
     }
     evaluateTryStatement(node) {
         const body = node.block;
@@ -749,7 +762,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 = materialize(self.ctx, Cause.squash(cause));
                 const parameter = handler.param;
                 self.scopes.push();
                 return Effect.gen(function* () {
@@ -776,7 +789,7 @@ class Frame {
         return Effect.gen(function* () {
             for (const declaration of node.declarations) {
                 if (declaration.type !== "VariableDeclarator") {
-                    throw new InterpreterRuntimeError("Unsupported variable declaration shape.", declaration);
+                    throw typeError("Unsupported variable declaration shape.", declaration);
                 }
                 const init = declaration.init;
                 // `var x` alone is a no-op: the binding was hoisted on function entry.
@@ -809,27 +822,27 @@ class Frame {
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (!(value instanceof ProgramObject)) {
-                    throw new InterpreterRuntimeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern, "InvalidDataValue");
+                if (!(value instanceof Obj)) {
+                    throw typeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern);
                 }
                 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 Obj(self.ctx.builtins.Object);
                         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.readProperty(value, key, property), mutable, property, initialize);
                 }
                 return;
             }
             if (pattern.type === "ArrayPattern") {
                 return yield* self.destructureArrayPattern(pattern, value, (target, item, context) => self.declarePattern(target, item, mutable, context, initialize));
             }
-            throw new InterpreterRuntimeError(`Unsupported binding pattern '${pattern.type}'.`, pattern);
+            throw typeError(`Unsupported binding pattern '${pattern.type}'.`, pattern);
         });
     }
     assignPattern(pattern, value, node) {
@@ -849,27 +862,27 @@ class Frame {
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (!(value instanceof ProgramObject)) {
-                    throw new InterpreterRuntimeError(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern, "InvalidDataValue");
+                if (!(value instanceof Obj)) {
+                    throw invalidData(`Object destructuring requires a data object or array value, received ${describeValue(value)}.`, pattern);
                 }
                 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 Obj(self.ctx.builtins.Object);
                         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.readProperty(value, key, property), property);
                 }
                 return;
             }
             if (pattern.type === "ArrayPattern") {
                 return yield* self.destructureArrayPattern(pattern, value, (target, item, context) => self.assignPattern(target, item, context));
             }
-            throw new InterpreterRuntimeError(`Unsupported assignment pattern '${pattern.type}'.`, node);
+            throw typeError(`Unsupported assignment pattern '${pattern.type}'.`, node);
         });
     }
     evaluateDefault(pattern) {
@@ -880,16 +893,16 @@ class Frame {
     destructureArrayPattern(pattern, value, consume) {
         const self = this;
         return Effect.gen(function* () {
-            const cursor = yield* self.syncIterator(value, pattern);
+            const cursor = yield* self.iterate(value, pattern);
             if (cursor === undefined) {
-                throw new InterpreterRuntimeError("Array destructuring requires a supported iterable value.", pattern);
+                throw typeError("Array destructuring requires a supported iterable value.", pattern);
             }
             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 Arr(self.ctx.builtins.Array) : undefined, element);
                     if (element.type === "RestElement")
                         return;
                     continue;
@@ -908,7 +921,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 Arr(self.ctx.builtins.Array, rest), element);
                     return;
                 }
                 const consumed = consume(element, step.done ? undefined : step.value, pattern);
@@ -920,7 +933,7 @@ class Frame {
     }
     destructuringPropertyKey(property) {
         if (property.type !== "Property" || property.kind !== "init") {
-            throw new InterpreterRuntimeError("Unsupported object destructuring property.", property);
+            throw typeError("Unsupported object destructuring property.", property);
         }
         const keyNode = property.key;
         if (property.computed) {
@@ -937,8 +950,10 @@ class Frame {
             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(this.ctx.builtins, [regex.pattern, regex.flags]));
+                if (typeof node.value === "bigint")
+                    throw typeError("BigInt literals are not supported.", node);
+                return Effect.succeed(node.value);
             }
             case "Identifier":
                 return Effect.sync(() => this.scopes.get(node.name, node));
@@ -981,7 +996,7 @@ class Frame {
                 return this.evaluateUpdateExpression(node);
             case "AwaitExpression": {
                 // Await always suspends, including for plain values.
-                return Effect.flatMap(this.evaluateExpression(node.argument), (value) => this.awaitValue(value, node));
+                return Effect.flatMap(this.evaluateExpression(node.argument), (value) => this.awaitValue(value));
             }
             case "YieldExpression":
                 return this.evaluateYieldExpression(node);
@@ -996,21 +1011,21 @@ 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 Native ? callee.construct : undefined;
             if (construct === undefined) {
                 // `new` itself is supported, so a non-constructible callee is a TypeError like JS rather than
                 // unsupported syntax. Built-ins like Number are real constructors in JS, so do not claim
                 // otherwise; say `new` is unsupported for them and point at the plain call.
                 const name = calleeDescription(node.callee);
-                const message = callee instanceof ProgramFunction
+                const message = callee instanceof Fn
                     ? `${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 Native
                         ? `new ${name}(...) is not supported; call ${name}(...) without new instead.`
                         : `${name} is not a constructor.`;
-                throw new InterpreterRuntimeError(message, node);
+                throw typeError(message, node);
             }
             const args = yield* self.evaluateCallArguments(node.arguments);
-            return yield* construct(args, callee, node);
+            return yield* self.native(() => construct(args, callee), node);
         });
     }
     evaluateBinaryExpression(node) {
@@ -1024,7 +1039,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 self.applyBinaryOperator(operator, lhs, rhs, node);
         });
     }
     applyBinaryOperator(operator, lhs, rhs, node) {
@@ -1032,16 +1047,16 @@ class Frame {
             return lhs === rhs;
         if (operator === "!==")
             return lhs !== rhs;
-        if (operator === "in" && rhs instanceof ProgramObject && !containsOpaqueReference(lhs)) {
+        if (operator === "in" && rhs instanceof Obj && !containsOpaqueReference(lhs)) {
             return has(rhs, lhs !== null && typeof lhs === "object" ? coerceToString(lhs) : lhs);
         }
         if (containsOpaqueReference(lhs) || containsOpaqueReference(rhs)) {
-            throw new InterpreterRuntimeError("Binary operators require data values.", node, "InvalidDataValue");
+            throw invalidData("Binary operators require data values.", node);
         }
         // 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 DateObj) {
                 return operator === "+" || operator === "==" || operator === "!=" ? coerceToString(operand) : operand.time;
             }
             return operand !== null && typeof operand === "object" ? coerceToString(operand) : operand;
@@ -1050,8 +1065,12 @@ class Frame {
         const l = coerceOperand(lhs);
         const r = coerceOperand(rhs);
         switch (operator) {
-            case "+":
-                return l + r;
+            case "+": {
+                const sum = l + r;
+                if (typeof sum === "string")
+                    checkStringLength(sum.length);
+                return sum;
+            }
             case "-":
                 return l - r;
             case "*":
@@ -1087,12 +1106,12 @@ class Frame {
             case ">>>":
                 return l >>> r;
             case "in":
-                if (!(rhs instanceof ProgramObject)) {
-                    throw new InterpreterRuntimeError("The 'in' operator requires a data object on the right-hand side.", node);
+                if (!(rhs instanceof Obj)) {
+                    throw typeError("The 'in' operator requires a data object on the right-hand side.", node);
                 }
                 return has(rhs, coerceOperand(lhs));
             default:
-                throw new InterpreterRuntimeError(`Unsupported binary operator '${operator}'.`, node);
+                throw typeError(`Unsupported binary operator '${operator}'.`, node);
         }
     }
     evaluateLogicalExpression(node) {
@@ -1104,7 +1123,7 @@ class Frame {
                 return left ? Effect.succeed(left) : this.evaluateExpression(node.right);
             if (operator === "??")
                 return left !== null && left !== undefined ? Effect.succeed(left) : this.evaluateExpression(node.right);
-            throw new InterpreterRuntimeError(`Unsupported logical operator '${operator}'.`, node);
+            throw typeError(`Unsupported logical operator '${operator}'.`, node);
         });
     }
     evaluateUnaryExpression(node) {
@@ -1124,9 +1143,9 @@ class Frame {
             if (operator === "void")
                 return undefined;
             if (containsOpaqueReference(value)) {
-                throw new InterpreterRuntimeError("Unary operators require data values.", node, "InvalidDataValue");
+                throw invalidData("Unary operators require data values.", node);
             }
-            const operand = value instanceof ProgramDate
+            const operand = value instanceof DateObj
                 ? value.time
                 : value !== null && typeof value === "object"
                     ? coerceToString(value)
@@ -1143,9 +1162,9 @@ class Frame {
                     result = ~operand;
                     break;
                 default:
-                    throw new InterpreterRuntimeError(`Unsupported unary operator '${operator}'.`, node);
+                    throw typeError(`Unsupported unary operator '${operator}'.`, node);
             }
-            return toProgram(this.runtime.prototypes, result, "Unary expression result");
+            return result;
         });
     }
     evaluateAssignmentExpression(node) {
@@ -1166,8 +1185,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");
-                    return self.scopes.set(name, next, left);
+                    return self.scopes.set(name, self.applyCompoundAssignment(operator, current, rightValue, node), left);
                 }
                 const rightValue = yield* self.evaluateNamed(node.right, name);
                 return self.scopes.set(name, rightValue, left);
@@ -1176,11 +1194,11 @@ 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 = self.applyCompoundAssignment(operator, current, rightValue, node);
                     return { write: true, next, result: next };
                 }));
             }
-            throw new InterpreterRuntimeError("Assignment target must be an Identifier or MemberExpression.", left);
+            throw typeError("Assignment target must be an Identifier or MemberExpression.", left);
         });
     }
     evaluateLogicalAssignment(node, left, operator) {
@@ -1205,7 +1223,7 @@ class Frame {
                 }))
                 : Effect.succeed({ write: false, next: current, result: current }));
         }
-        throw new InterpreterRuntimeError("Assignment target must be an Identifier or MemberExpression.", left);
+        throw typeError("Assignment target must be an Identifier or MemberExpression.", left);
     }
     evaluateUpdateExpression(node) {
         const operator = node.operator;
@@ -1213,13 +1231,13 @@ class Frame {
         const prefix = node.prefix;
         const increment = operator === "++" ? 1 : operator === "--" ? -1 : undefined;
         if (increment === undefined) {
-            throw new InterpreterRuntimeError(`Unsupported update operator '${operator}'.`, node);
+            throw typeError(`Unsupported update operator '${operator}'.`, node);
         }
         // CodeMode numeric coercion, not host Number(): null-prototype data objects would make
         // the host throw during ToPrimitive, and opaque runtime references must reject clearly.
         const operand = (current) => {
             if (containsOpaqueReference(current)) {
-                throw new InterpreterRuntimeError(`'${operator}' requires a data value.`, argument, "InvalidDataValue");
+                throw invalidData(`'${operator}' requires a data value.`, argument);
             }
             return coerceToNumber(current);
         };
@@ -1239,7 +1257,7 @@ class Frame {
                 return Effect.succeed({ write: true, next, result: prefix ? next : value });
             });
         }
-        throw new InterpreterRuntimeError("Update target must be an Identifier or MemberExpression.", argument);
+        throw typeError("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) {
@@ -1256,7 +1274,7 @@ class Frame {
             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);
+            return yield* self.call(callable, thisValue, args, node, callee);
         });
     }
     readMethod(node) {
@@ -1271,22 +1289,27 @@ class Frame {
         });
     }
     // The single dispatch for every invocation: call expressions and callbacks share it.
-    invokeCallable(callable, thisValue, args, node, callee) {
+    call(callable, thisValue, args, node, callee) {
         const self = this;
         return Effect.gen(function* () {
             if (callable instanceof ToolReference) {
                 if (callable.path.length === 0) {
-                    throw new InterpreterRuntimeError("The tools root is not callable.", callee ?? node);
+                    throw typeError("The tools root is not callable.", callee ?? node);
                 }
                 return yield* self.createToolCallPromise(callable.path, args);
             }
-            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 Fn)
+                return yield* self.invokeFunction(callable, args, node);
+            if (callable instanceof Native) {
+                return yield* self.native(() => callable.call(thisValue, args), node);
+            }
+            throw typeError(`${calleeDescription(callee)} is not a function.`, callee ?? node);
         });
     }
+    // Built-ins throw without a location, synchronously or inside their Effect; the call site supplies it.
+    native(body, node) {
+        return Effect.provideService(Effect.catchDefect(Effect.suspend(body), (defect) => Effect.die(locate(defect, node))), CallSite, { node, depth: this.depth });
+    }
     evaluateCallArguments(argNodes) {
         const self = this;
         return Effect.gen(function* () {
@@ -1294,9 +1317,9 @@ class Frame {
             for (const argNode of argNodes) {
                 if (argNode.type === "SpreadElement") {
                     const spread = yield* self.evaluateExpression(argNode.argument);
-                    const cursor = yield* self.syncIterator(spread, argNode);
+                    const cursor = yield* self.iterate(spread, argNode);
                     if (cursor === undefined)
-                        throw new InterpreterRuntimeError("Spread arguments require a synchronous iterable.", argNode);
+                        throw typeError("Spread arguments require a synchronous iterable.", argNode);
                     while (true) {
                         const step = yield* cursor.next;
                         if (step.done)
@@ -1311,49 +1334,54 @@ class Frame {
             return args;
         });
     }
-    invokeFunction(fn, args) {
+    // A callback invoked by a built-in runs below the call that invoked the built-in, so the deeper of the two counts.
+    invokeFunction(fn, args, node) {
         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.
-            const paramScope = invocation.scopes.current();
-            for (const parameter of fn.parameters) {
-                for (const name of collectPatternNames(parameter)) {
-                    paramScope.set(name, { mutable: true, value: undefined, initialized: false });
+        return Effect.flatMap(CallSite, (site) => {
+            const depth = Math.max(self.depth, site.depth) + 1;
+            if (depth > MAX_CALL_DEPTH)
+                throw rangeError("Maximum call stack size exceeded", node);
+            const invocation = new Frame(this.ctx, new ScopeStack([...fn.capturedScopes, new Map()]), depth);
+            const run = Effect.gen(function* () {
+                // Seed all parameters first so defaults cannot fall through to same-named outer bindings.
+                const paramScope = invocation.scopes.current();
+                for (const parameter of fn.parameters) {
+                    for (const name of collectPatternNames(parameter)) {
+                        paramScope.set(name, { mutable: true, value: undefined, initialized: false });
+                    }
                 }
-            }
-            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);
-                    break;
+                for (const [index, parameter] of fn.parameters.entries()) {
+                    if (parameter.type === "RestElement") {
+                        yield* invocation.declarePattern(parameter.argument, new Arr(self.ctx.builtins.Array, args.slice(index)), true, parameter, true);
+                        break;
+                    }
+                    yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
                 }
-                yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
-            }
-            if (fn.body.type === "BlockStatement") {
-                invocation.scopes.push();
-                invocation.hoistVars(fn.body.body, paramScope);
-                const result = yield* invocation.evaluateStatement(fn.body);
-                return result.kind === "return" ? result.value : undefined;
-            }
-            return yield* invocation.evaluateExpression(fn.body);
+                if (fn.body.type === "BlockStatement") {
+                    invocation.scopes.push();
+                    invocation.hoistVars(fn.body.body, paramScope);
+                    const result = yield* invocation.evaluateStatement(fn.body);
+                    return result.kind === "return" ? result.value : undefined;
+                }
+                return yield* invocation.evaluateExpression(fn.body);
+            });
+            if (fn.generator)
+                return Effect.succeed(this.createGenerator(invocation, run, fn.async));
+            if (!fn.async)
+                return run;
+            return this.ctx.pending.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.ctx, value, self)));
         });
-        if (fn.generator)
-            return Effect.succeed(this.createGenerator(invocation, run, fn.async));
-        if (!fn.async)
-            return run;
-        return this.runtime.promises.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, self)));
     }
     createGenerator(invocation, run, asynchronous) {
         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 builtins = this.ctx.builtins;
+        const result = (value, done) => record(builtins.Object, { value, done });
+        const request = (kind, value) => {
             const request = { kind, value, response: Deferred.makeUnsafe() };
-            if (!asynchronous && state.active) {
-                return Effect.fail(new InterpreterRuntimeError("Generator is already running.", node));
-            }
+            if (!asynchronous && state.active)
+                return Effect.die(typeError("Generator is already running."));
             if (asynchronous && (state.completed || (!state.started && kind !== "next"))) {
                 state.started = true;
                 state.completed = true;
@@ -1361,19 +1389,19 @@ class Frame {
                 if (state.draining)
                     return Deferred.await(request.response);
                 state.draining = true;
-                return Effect.andThen(this.runtime.promises.fork(invocation
+                return Effect.andThen(this.ctx.pending.fork(invocation
                     .completeGeneratorRequests(state, true)
                     .pipe(Effect.ensuring(Effect.sync(() => (state.draining = false))))), Deferred.await(request.response));
             }
             if (state.completed) {
                 if (kind === "throw")
-                    return Effect.fail(new ProgramThrow(value));
+                    return Effect.fail(new Throw(value));
                 return Effect.succeed(result(kind === "return" ? value : undefined, true));
             }
             if (!state.started && kind !== "next") {
                 state.completed = true;
                 if (kind === "throw")
-                    return Effect.fail(new ProgramThrow(value));
+                    return Effect.fail(new Throw(value));
                 return Effect.succeed(result(value, true));
             }
             state.pending.push(request);
@@ -1399,23 +1427,23 @@ class Frame {
                     yield* invocation.completeGeneratorRequests(state, asynchronous);
                     state.completed = true;
                 });
-                return Effect.andThen(this.runtime.promises.fork(body), Deferred.await(request.response));
+                return Effect.andThen(this.ctx.pending.fork(body), Deferred.await(request.response));
             }
             return Deferred.await(request.response);
         };
-        const generator = new ProgramGenerator(asynchronous ? protos.AsyncGenerator : protos.Generator, asynchronous, request);
+        const generator = new GeneratorObj(asynchronous ? builtins.AsyncGenerator : builtins.Generator, asynchronous, request);
         return generator;
     }
     completeGeneratorRequests(state, asynchronous) {
         const self = this;
-        const result = (value, done) => record(self.runtime.prototypes.Object, { value, done });
+        const result = (value, done) => record(self.ctx.builtins.Object, { value, done });
         return Effect.gen(function* () {
             while (true) {
                 const pending = self.dequeueGeneratorRequest(state);
                 if (!pending)
                     return;
                 if (pending.kind === "throw") {
-                    Deferred.doneUnsafe(pending.response, Exit.fail(new ProgramThrow(pending.value)));
+                    Deferred.doneUnsafe(pending.response, Exit.fail(new Throw(pending.value)));
                     continue;
                 }
                 if (asynchronous && pending.kind === "return") {
@@ -1450,7 +1478,7 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             if (!self.generatorState)
-                throw new InterpreterRuntimeError("yield is only valid inside a generator.", node);
+                throw typeError("yield is only valid inside a generator.", node);
             if (node.delegate) {
                 const value = argument ? yield* self.evaluateExpression(argument) : undefined;
                 return yield* self.delegateYield(value, node);
@@ -1463,15 +1491,15 @@ class Frame {
     suspendGenerator(value, node) {
         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 })));
+            throw typeError("Generator has no active request.", node);
+        Deferred.doneUnsafe(state.active.response, Exit.succeed(record(this.ctx.builtins.Object, { value, done: false })));
         state.active = undefined;
         return Effect.flatMap(this.takeGeneratorRequest(state), (request) => {
             state.active = request;
             if (request.kind === "next")
                 return Effect.succeed(request.value);
             if (request.kind === "throw")
-                return Effect.fail(new ProgramThrow(request.value));
+                return Effect.fail(new Throw(request.value));
             return this.generatorAsync
                 ? Effect.flatMap(this.awaitValue(request.value), (value) => Effect.fail(new GeneratorReturn(value)))
                 : Effect.fail(new GeneratorReturn(request.value));
@@ -1480,14 +1508,15 @@ class Frame {
     delegateYield(value, node) {
         const self = this;
         return Effect.gen(function* () {
-            if (value instanceof ProgramArray ||
+            if (value instanceof Arr ||
                 typeof value === "string" ||
-                value instanceof ProgramMap ||
-                value instanceof ProgramSet ||
-                value instanceof ProgramURLSearchParams) {
-                const cursor = yield* self.syncIterator(value, node);
+                value instanceof MapObj ||
+                value instanceof SetObj ||
+                value instanceof URLSearchParamsObj ||
+                value instanceof Bytes) {
+                const cursor = yield* self.iterate(value, node);
                 if (!cursor)
-                    throw new InterpreterRuntimeError("Built-in iterator is unavailable.", node);
+                    throw typeError("Built-in iterator is unavailable.", node);
                 while (true) {
                     const step = yield* cursor.next;
                     if (step.done)
@@ -1500,16 +1529,16 @@ class Frame {
                         yield* cursor.close;
                         return yield* Effect.fail(error);
                     }
-                    if (error instanceof ProgramThrow) {
+                    if (error instanceof Throw) {
                         yield* cursor.close;
-                        throw new InterpreterRuntimeError("The delegated iterator does not provide a throw() method.", node);
+                        throw typeError("The delegated iterator does not provide a throw() method.", node);
                     }
                     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 typeError("yield* requires a compatible iterable value.", node);
             let kind = "next";
             let input = undefined;
             while (true) {
@@ -1518,9 +1547,9 @@ class Frame {
                     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 typeError("The delegated iterator does not provide a throw() method.", node);
                 }
-                const called = yield* self.invokeCallable(self.requireIteratorMethod(method, `Iterator ${kind}`, node), iterator.iterator, [input], node);
+                const called = yield* self.call(self.requireIteratorMethod(method, `Iterator ${kind}`, node), iterator.iterator, [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
@@ -1538,7 +1567,7 @@ class Frame {
                     continue;
                 }
                 const error = Cause.squash(resumed.cause);
-                if (!(error instanceof GeneratorReturn) && !(error instanceof ProgramThrow)) {
+                if (!(error instanceof GeneratorReturn) && !(error instanceof Throw)) {
                     return yield* Effect.failCause(resumed.cause);
                 }
                 kind = error instanceof GeneratorReturn ? "return" : "throw";
@@ -1547,7 +1576,7 @@ class Frame {
         });
     }
     evaluateObjectExpression(node) {
-        const objectValue = new ProgramObject(this.runtime.prototypes.Object);
+        const objectValue = new Obj(this.ctx.builtins.Object);
         const self = this;
         return Effect.gen(function* () {
             for (const property of node.properties) {
@@ -1555,11 +1584,11 @@ 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(self.ctx, "Object spread", spread, property));
                     continue;
                 }
                 if (property.kind !== "init") {
-                    throw new InterpreterRuntimeError("Only init object properties are supported.", property);
+                    throw typeError("Only init object properties are supported.", property);
                 }
                 const keyNode = property.key;
                 let key;
@@ -1573,7 +1602,7 @@ class Frame {
                     key = self.toPropertyKey(keyNode.value, keyNode);
                 }
                 else {
-                    throw new InterpreterRuntimeError("Unsupported object property key shape.", keyNode);
+                    throw typeError("Unsupported object property key shape.", keyNode);
                 }
                 const name = key === IteratorSymbol
                     ? "[Symbol.iterator]"
@@ -1597,9 +1626,9 @@ class Frame {
                 }
                 if (element.type === "SpreadElement") {
                     const spread = yield* self.evaluateExpression(element.argument);
-                    const cursor = yield* self.syncIterator(spread, element);
+                    const cursor = yield* self.iterate(spread, element);
                     if (cursor === undefined)
-                        throw new InterpreterRuntimeError("Array spread requires a synchronous iterable.", element);
+                        throw typeError("Array spread requires a synchronous iterable.", element);
                     while (true) {
                         const step = yield* cursor.next;
                         if (step.done)
@@ -1611,7 +1640,7 @@ class Frame {
                     values.push(yield* self.evaluateExpression(element));
                 }
             }
-            return new ProgramArray(self.runtime.prototypes.Array, values);
+            return new Arr(self.ctx.builtins.Array, values);
         });
     }
     evaluateTemplateLiteral(node) {
@@ -1624,12 +1653,14 @@ class Frame {
                 const quasi = quasis[index];
                 // acorn only omits `cooked` for invalid escapes in tagged templates, which are unsupported.
                 if (typeof quasi.value.cooked !== "string") {
-                    throw new InterpreterRuntimeError("Invalid template literal quasi.", quasi);
+                    throw typeError("Invalid template literal quasi.", quasi);
                 }
                 output += quasi.value.cooked;
+                checkStringLength(output.length);
                 if (index < expressions.length) {
                     const raw = yield* self.evaluateExpression(expressions[index]);
-                    output += coerceToString(toProgram(self.runtime.prototypes, raw, "Template interpolation"));
+                    output += coerceToString(raw);
+                    checkStringLength(output.length);
                 }
             }
             return output;
@@ -1640,7 +1671,7 @@ class Frame {
     }
     applyCompoundAssignment(operator, current, incoming, node) {
         if (!compoundOperators.has(operator)) {
-            throw new InterpreterRuntimeError(`Unsupported assignment operator '${operator}'.`, node);
+            throw typeError(`Unsupported assignment operator '${operator}'.`, node);
         }
         return this.applyBinaryOperator(operator.slice(0, -1), current, incoming, node);
     }
@@ -1665,39 +1696,43 @@ class Frame {
                     : self.toPropertyKey(yield* self.evaluateExpression(propertyNode), propertyNode);
             if (objectValue instanceof ToolReference) {
                 if (typeof key !== "string") {
-                    throw new InterpreterRuntimeError("Tool paths must use string property names.", propertyNode);
+                    throw typeError("Tool paths must use string property names.", propertyNode);
                 }
                 return new ToolReference([...objectValue.path, key]);
             }
-            if (objectValue instanceof ProgramObject)
+            if (objectValue instanceof Obj)
                 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;
+            const builtins = self.ctx.builtins;
             if (typeof objectValue === "string") {
                 if (key === "length")
                     return { value: 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 { target: builtins.String, key, receiver: objectValue };
             }
             if (typeof objectValue === "number")
-                return { target: protos.Number, key, receiver: objectValue };
+                return { target: builtins.Number, key, receiver: objectValue };
             if (typeof objectValue === "boolean")
-                return { target: protos.Boolean, key, receiver: objectValue };
+                return { target: builtins.Boolean, key, receiver: objectValue };
             if (objectValue === null || objectValue === undefined) {
-                throw new InterpreterRuntimeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode);
+                throw typeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode);
             }
-            throw new InterpreterRuntimeError("Cannot access a property on a non-object value.", objectNode);
+            throw typeError("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");
+        if (reference.target instanceof PromiseObj && !has(reference.target, reference.key)) {
+            throw invalidData("This value is an un-awaited Promise; await it first - e.g. `const result = await tools.ns.tool(...)`.", node.object);
         }
+        return this.readProperty(reference.target, reference.key, node, reference.receiver);
+    }
+    // Accessors throw without a location; the member or pattern that read them supplies it.
+    readProperty(target, key, node, receiver = target) {
         try {
-            return get(reference.target, reference.key, reference.receiver);
+            return get(target, key, receiver);
         }
         catch (error) {
             throw locate(error, node);
@@ -1720,17 +1755,17 @@ class Frame {
     evaluateDeleteExpression(argument) {
         const target = argument.type === "ChainExpression" ? argument.expression : argument;
         if (target.type !== "MemberExpression") {
-            throw new InterpreterRuntimeError("Only data fields may be deleted.", argument);
+            throw typeError("Only data fields may be deleted.", argument);
         }
         return Effect.map(this.getMemberReference(target), (reference) => {
             if (reference === OptionalShortCircuit)
                 return true;
             if (reference instanceof ToolReference || "value" in reference || reference.receiver !== reference.target) {
-                throw new InterpreterRuntimeError("Only data fields may be deleted.", target, "InvalidDataValue");
+                throw invalidData("Only data fields may be deleted.", target);
             }
             if (remove(reference.target, reference.key))
                 return true;
-            throw new InterpreterRuntimeError(`Cannot delete property '${String(reference.key)}'.`, target);
+            throw typeError(`Cannot delete property '${String(reference.key)}'.`, target);
         });
     }
     // Resolve side-effecting object and key expressions exactly once.
@@ -1739,10 +1774,10 @@ class Frame {
         return Effect.gen(function* () {
             const reference = yield* self.getMemberReference(node);
             if (reference === OptionalShortCircuit || reference instanceof ToolReference || "value" in reference) {
-                throw new InterpreterRuntimeError("Only data fields may be assigned.", node);
+                throw typeError("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);
+                throw typeError(`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));
@@ -1752,9 +1787,9 @@ class Frame {
         });
     }
     assignToReference(target, key, next, node) {
-        rejectCircularInsertion(target, next, target instanceof ProgramArray ? "Array assignment result" : "Object assignment result", node);
         const written = (() => {
             try {
+                rejectCircularInsertion(target, next, target instanceof Arr ? "Array assignment result" : "Object assignment result");
                 return set(target, key, next);
             }
             catch (error) {
@@ -1763,9 +1798,9 @@ class Frame {
         })();
         if (written)
             return;
-        if (target instanceof ProgramArray && key === "length")
+        if (target instanceof Arr && key === "length")
             throw rangeError("Invalid array length", node);
-        throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node);
+        throw typeError(`Cannot assign to read only property '${String(key)}'.`, node);
     }
     toPropertyKey(value, node) {
         if (typeof value === "string" || typeof value === "number") {
@@ -1773,6 +1808,6 @@ class Frame {
         }
         if (value === AsyncIteratorSymbol || value === IteratorSymbol)
             return value;
-        throw new InterpreterRuntimeError("Property key must be a string or number, or Symbol.asyncIterator/Symbol.iterator.", node);
+        throw typeError("Property key must be a string or number, or Symbol.asyncIterator/Symbol.iterator.", node);
     }
 }