@opencode/codemode 0.0.0-dev-19631 → 0.0.0-dev-19633

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

@@ -1,13 +1,13 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
 import { toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
-import { AsyncIteratorSymbol, CallSite, GeneratorReturn, IteratorSymbol, OptionalShortCircuit, invalidData, ProgramThrow, rangeError, typeError, unsupportedSyntax, } from "./model.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";
@@ -49,7 +49,7 @@ const instanceofValue = (lhs, rhs, node) => {
         throw typeError("The right-hand side of 'instanceof' is not callable.", node);
     }
     const prototype = get(rhs, "prototype");
-    if (!(prototype instanceof ProgramObject)) {
+    if (!(prototype instanceof Obj)) {
         throw typeError("The right-hand side of 'instanceof' has no 'prototype' object.", node);
     }
     return hasPrototype(lhs, prototype);
@@ -143,51 +143,49 @@ const loopDeclaration = (left, statement) => {
     };
 };
 /** 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) => this.root.invokeCallable(callable, thisValue, args),
-            settlePromise: (promise) => this.root.settlePromise(promise),
-            syncIterator: (value) => this.root.syncIterator(value),
-            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);
+    }
 }
 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, 
+    constructor(ctx, scopes, 
     /** Nested call depth; resets when an await resumes, since the continuation runs from the job queue. */
     depth = 0) {
-        this.runtime = runtime;
+        this.ctx = ctx;
         this.scopes = scopes;
         this.depth = depth;
     }
@@ -215,20 +213,20 @@ class Frame {
                 }
             }
             // The implicit async body adopts returned promises before copy-out.
-            value = yield* resolvePromiseValue(self.runtime.runner, value);
+            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(Effect.suspend(() => this.ctx.tools.execute(path, 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) {
@@ -294,7 +292,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) {
@@ -472,7 +470,7 @@ 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 invalidData(`${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, or URLSearchParams, or custom iterator value.`, node);
             }
@@ -529,7 +527,7 @@ class Frame {
         })));
     }
     awaitValue(value) {
-        return Effect.flatMap(resolvePromise(this.runtime.runner, this.runtime.promises, value), (promise) => Effect.ensuring(this.settlePromise(promise), Effect.sync(() => (this.depth = 0))));
+        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;
@@ -543,26 +541,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,
@@ -577,14 +577,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,
@@ -597,10 +597,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;
@@ -631,10 +631,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;
@@ -651,7 +651,7 @@ class Frame {
         });
     }
     requireIteratorObject(value, context, node) {
-        if (value instanceof ProgramObject)
+        if (value instanceof Obj)
             return value;
         throw typeError(`${context} must be an object.`, node);
     }
@@ -663,10 +663,10 @@ class Frame {
     // 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;
@@ -742,7 +742,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;
@@ -754,7 +754,7 @@ class Frame {
                 if (cause.reasons.some(Cause.isInterruptReason) || Cause.squash(cause) instanceof GeneratorReturn || !handler) {
                     return Effect.failCause(cause);
                 }
-                const caught = materialize(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* () {
@@ -814,13 +814,13 @@ class Frame {
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (!(value instanceof ProgramObject)) {
+                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;
@@ -854,13 +854,13 @@ class Frame {
                 return;
             }
             if (pattern.type === "ObjectPattern") {
-                if (!(value instanceof ProgramObject)) {
+                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;
@@ -885,7 +885,7 @@ 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 typeError("Array destructuring requires a supported iterable value.", pattern);
             }
@@ -894,7 +894,7 @@ class Frame {
                 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;
@@ -913,7 +913,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);
@@ -942,8 +942,8 @@ class Frame {
             case "Literal": {
                 const regex = node.regex;
                 if (regex)
-                    return Effect.sync(() => constructRegExp(this.runtime.prototypes, [regex.pattern, regex.flags]));
-                return Effect.sync(() => toProgram(this.runtime.prototypes, node.value, "Literal"));
+                    return Effect.sync(() => constructRegExp(this.ctx.builtins, [regex.pattern, regex.flags]));
+                return Effect.sync(() => toProgram(this.ctx.builtins, node.value, "Literal"));
             }
             case "Identifier":
                 return Effect.sync(() => this.scopes.get(node.name, node));
@@ -1001,15 +1001,15 @@ 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 typeError(message, node);
@@ -1029,7 +1029,7 @@ class Frame {
             const rhs = yield* self.evaluateExpression(node.right);
             if (operator === "instanceof")
                 return instanceofValue(lhs, rhs, node);
-            return toProgram(self.runtime.prototypes, self.applyBinaryOperator(operator, lhs, rhs, node), "Binary expression result");
+            return toProgram(self.ctx.builtins, self.applyBinaryOperator(operator, lhs, rhs, node), "Binary expression result");
         });
     }
     applyBinaryOperator(operator, lhs, rhs, node) {
@@ -1037,7 +1037,7 @@ 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)) {
@@ -1046,7 +1046,7 @@ class Frame {
         // Null-prototype data needs explicit primitive coercion; identity and `in` retain raw objects.
         // Dates use their default string hint for addition and loose equality, and epoch time elsewhere.
         const coerceOperand = (operand) => {
-            if (operand instanceof ProgramDate) {
+            if (operand instanceof DateObj) {
                 return operator === "+" || operator === "==" || operator === "!=" ? coerceToString(operand) : operand.time;
             }
             return operand !== null && typeof operand === "object" ? coerceToString(operand) : operand;
@@ -1096,7 +1096,7 @@ class Frame {
             case ">>>":
                 return l >>> r;
             case "in":
-                if (!(rhs instanceof ProgramObject)) {
+                if (!(rhs instanceof Obj)) {
                     throw typeError("The 'in' operator requires a data object on the right-hand side.", node);
                 }
                 return has(rhs, coerceOperand(lhs));
@@ -1135,7 +1135,7 @@ class Frame {
             if (containsOpaqueReference(value)) {
                 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)
@@ -1154,7 +1154,7 @@ class Frame {
                 default:
                     throw typeError(`Unsupported unary operator '${operator}'.`, node);
             }
-            return toProgram(this.runtime.prototypes, result, "Unary expression result");
+            return toProgram(this.ctx.builtins, result, "Unary expression result");
         });
     }
     evaluateAssignmentExpression(node) {
@@ -1175,7 +1175,7 @@ class Frame {
                 if (operator !== "=") {
                     const current = self.scopes.get(name, left);
                     const rightValue = yield* self.evaluateExpression(node.right);
-                    const next = toProgram(self.runtime.prototypes, self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
+                    const next = toProgram(self.ctx.builtins, self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
                     return self.scopes.set(name, next, left);
                 }
                 const rightValue = yield* self.evaluateNamed(node.right, name);
@@ -1185,7 +1185,7 @@ class Frame {
                 return yield* self.modifyMember(left, (current) => Effect.map(self.evaluateExpression(node.right), (rightValue) => {
                     if (operator === "=")
                         return { write: true, next: rightValue, result: rightValue };
-                    const next = toProgram(self.runtime.prototypes, self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
+                    const next = toProgram(self.ctx.builtins, self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
                     return { write: true, next, result: next };
                 }));
             }
@@ -1265,7 +1265,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) {
@@ -1280,7 +1280,7 @@ 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) {
@@ -1289,9 +1289,9 @@ class Frame {
                 }
                 return yield* self.createToolCallPromise(callable.path, args);
             }
-            if (callable instanceof ProgramFunction)
+            if (callable instanceof Fn)
                 return yield* self.invokeFunction(callable, args, node);
-            if (callable instanceof NativeFunction) {
+            if (callable instanceof Native) {
                 return yield* self.native(() => callable.call(thisValue, args), node);
             }
             throw typeError(`${calleeDescription(callee)} is not a function.`, callee ?? node);
@@ -1308,7 +1308,7 @@ 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 typeError("Spread arguments require a synchronous iterable.", argNode);
                     while (true) {
@@ -1332,7 +1332,7 @@ class Frame {
             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.runtime, new ScopeStack([...fn.capturedScopes, new Map()]), depth);
+            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();
@@ -1343,7 +1343,7 @@ class Frame {
                 }
                 for (const [index, parameter] of fn.parameters.entries()) {
                     if (parameter.type === "RestElement") {
-                        yield* invocation.declarePattern(parameter.argument, new ProgramArray(self.runtime.prototypes.Array, args.slice(index)), true, parameter, true);
+                        yield* invocation.declarePattern(parameter.argument, new Arr(self.ctx.builtins.Array, args.slice(index)), true, parameter, true);
                         break;
                     }
                     yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
@@ -1360,15 +1360,15 @@ class Frame {
                 return Effect.succeed(this.createGenerator(invocation, run, fn.async));
             if (!fn.async)
                 return run;
-            return this.runtime.promises.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, self)));
+            return this.ctx.pending.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.ctx, value, 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 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)
@@ -1380,19 +1380,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);
@@ -1418,23 +1418,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") {
@@ -1483,14 +1483,14 @@ class Frame {
         const state = this.generatorState;
         if (!state?.active)
             throw typeError("Generator has no active request.", node);
-        Deferred.doneUnsafe(state.active.response, Exit.succeed(record(this.runtime.prototypes.Object, { value, done: false })));
+        Deferred.doneUnsafe(state.active.response, Exit.succeed(record(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));
@@ -1499,12 +1499,13 @@ 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 typeError("Built-in iterator is unavailable.", node);
                 while (true) {
@@ -1519,7 +1520,7 @@ class Frame {
                         yield* cursor.close;
                         return yield* Effect.fail(error);
                     }
-                    if (error instanceof ProgramThrow) {
+                    if (error instanceof Throw) {
                         yield* cursor.close;
                         throw typeError("The delegated iterator does not provide a throw() method.", node);
                     }
@@ -1539,7 +1540,7 @@ class Frame {
                     yield* self.closeIterator(iterator, node, self.generatorAsync);
                     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
@@ -1557,7 +1558,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";
@@ -1566,7 +1567,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) {
@@ -1574,7 +1575,7 @@ class Frame {
                     const spread = yield* self.evaluateExpression(property.argument);
                     if (spread === null || spread === undefined)
                         continue;
-                    assign(objectValue, enumerableSource(self.runtime.runner, "Object spread", spread, property));
+                    assign(objectValue, enumerableSource(self.ctx, "Object spread", spread, property));
                     continue;
                 }
                 if (property.kind !== "init") {
@@ -1616,7 +1617,7 @@ 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 typeError("Array spread requires a synchronous iterable.", element);
                     while (true) {
@@ -1630,7 +1631,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) {
@@ -1649,7 +1650,7 @@ class Frame {
                 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(toProgram(self.ctx.builtins, raw, "Template interpolation"));
                     checkStringLength(output.length);
                 }
             }
@@ -1690,22 +1691,22 @@ class Frame {
                 }
                 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 typeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode);
             }
@@ -1714,7 +1715,7 @@ class Frame {
     }
     readReference(reference, node) {
         // Reject unknown promise properties so a missing await cannot hide.
-        if (reference.target instanceof ProgramPromise && !has(reference.target, reference.key)) {
+        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);
@@ -1779,7 +1780,7 @@ class Frame {
     assignToReference(target, key, next, node) {
         const written = (() => {
             try {
-                rejectCircularInsertion(target, next, target instanceof ProgramArray ? "Array assignment result" : "Object assignment result");
+                rejectCircularInsertion(target, next, target instanceof Arr ? "Array assignment result" : "Object assignment result");
                 return set(target, key, next);
             }
             catch (error) {
@@ -1788,7 +1789,7 @@ class Frame {
         })();
         if (written)
             return;
-        if (target instanceof ProgramArray && key === "length")
+        if (target instanceof Arr && key === "length")
             throw rangeError("Invalid array length", node);
         throw typeError(`Cannot assign to read only property '${String(key)}'.`, node);
     }