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

package/dist/codemode.js

@@ -72,6 +72,6 @@ export const make = (options = {}) => {
     }
     return {
         catalog: prepared.catalog,
-        execute: (code) => executeProgram(code, prepared, limits, options, (host) => extensionGlobals(host, extensions)),
+        execute: (code) => executeProgram(code, prepared, limits, options, (ctx) => extensionGlobals(ctx, extensions)),
     };
 };

package/dist/data.d.ts

@@ -1,6 +1,6 @@
 export * as Data from "./data.js";
 import type { DiagnosticKind } from "./codemode.js";
-import type { Prototypes } from "./interpreter/intrinsics.js";
+import type { Builtins } from "./interpreter/intrinsics.js";
 export declare const MAX_VALUE_DEPTH = 32;
 export declare class ToolRuntimeError extends Error {
     readonly kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">;
@@ -12,12 +12,12 @@ export declare class ToolRuntimeError extends Error {
  * Map, Set, URL, and URLSearchParams become their built-in wrappers, and host objects and arrays
  * are copied.
  */
-export declare const toProgram: (protos: Prototypes, value: unknown, label: string) => unknown;
+export declare const toProgram: (builtins: Builtins, value: unknown, label: string) => unknown;
 /**
  * Brings host data into the program: Date and URL become strings, other host collections become
  * empty objects, and objects become program copies. Used for tool results and parsed JSON.
  */
-export declare const fromData: (protos: Prototypes, value: unknown, label: string) => unknown;
+export declare const fromData: (builtins: Builtins, value: unknown, label: string) => unknown;
 /**
  * Takes a program value out as plain JSON: runtime values serialize like `JSON.stringify` would,
  * non-finite numbers become null, and array holes become null. `undefined` object properties are

package/dist/data.js

@@ -1,5 +1,5 @@
 export * as Data from "./data.js";
-import { Callable, define, entries, get, isWrapper, parseArrayIndex, ProgramArray, ProgramDate, ProgramError, ProgramGenerator, ProgramHandle, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./interpreter/objects.js";
+import { Callable, define, entries, get, isWrapper, parseArrayIndex, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, Handle, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "./interpreter/objects.js";
 export const MAX_VALUE_DEPTH = 32;
 export class ToolRuntimeError extends Error {
     kind;
@@ -16,12 +16,12 @@ export class ToolRuntimeError extends Error {
  * Map, Set, URL, and URLSearchParams become their built-in wrappers, and host objects and arrays
  * are copied.
  */
-export const toProgram = (protos, value, label) => copy(value, label, "program", 0, new Set(), protos);
+export const toProgram = (builtins, value, label) => copy(value, label, "program", 0, new Set(), builtins);
 /**
  * Brings host data into the program: Date and URL become strings, other host collections become
  * empty objects, and objects become program copies. Used for tool results and parsed JSON.
  */
-export const fromData = (protos, value, label) => copy(value, label, "data", 0, new Set(), protos);
+export const fromData = (builtins, value, label) => copy(value, label, "data", 0, new Set(), builtins);
 /**
  * Takes a program value out as plain JSON: runtime values serialize like `JSON.stringify` would,
  * non-finite numbers become null, and array holes become null. `undefined` object properties are
@@ -34,8 +34,8 @@ export const fromData = (protos, value, label) => copy(value, label, "data", 0,
  * behavior.
  */
 export const toData = (value, label, undefinedAs = "json", boundary = true) => copy(value, label, undefinedAs, 0, new Set(), undefined, boundary);
-const copy = (value, label, mode, depth, seen, protos, boundary = true) => {
-    const next = (item) => copy(item, label, mode, depth + 1, seen, protos, boundary);
+const copy = (value, label, mode, depth, seen, builtins, boundary = true) => {
+    const next = (item) => copy(item, label, mode, depth + 1, seen, builtins, boundary);
     if (depth > MAX_VALUE_DEPTH) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
     }
@@ -48,57 +48,63 @@ const copy = (value, label, mode, depth, seen, protos, boundary = true) => {
     if (typeof value !== "object") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
     }
-    if (value instanceof ProgramPromise) {
+    if (value instanceof PromiseObj) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} contains an un-awaited Promise; await tool calls (e.g. \`const result = await tools.ns.tool(...)\`) before using their results.`);
     }
-    if ((value instanceof Callable || value instanceof ProgramGenerator) && mode !== "program") {
+    if ((value instanceof Callable || value instanceof GeneratorObj) && mode !== "program") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
     }
-    if (value instanceof ProgramHandle && mode !== "program") {
+    if (value instanceof Handle && mode !== "program") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} contains a ${value.instance.constructor.name}, which only extension functions accept.`);
     }
     // Host-produced input never holds program objects; one arriving here would come back as a host object.
-    if (value instanceof ProgramObject && mode === "data") {
+    if (value instanceof Obj && mode === "data") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must be host data, not a program value.`);
     }
-    if (protos !== undefined && mode === "program") {
-        if (value instanceof ProgramObject)
+    if (builtins !== undefined && mode === "program") {
+        if (value instanceof Obj)
             return value;
         if (value instanceof Date)
-            return new ProgramDate(protos.Date, value.getTime());
+            return new DateObj(builtins.Date, value.getTime());
         if (value instanceof RegExp)
-            return new ProgramRegExp(protos.RegExp, value.source, value.flags);
+            return new RegExpObj(builtins.RegExp, value.source, value.flags);
         if (value instanceof Map) {
-            const wrapped = new ProgramMap(protos.Map);
+            const wrapped = new MapObj(builtins.Map);
             for (const [key, item] of value.entries())
                 wrapped.map.set(next(key), next(item));
             return wrapped;
         }
         if (value instanceof Set) {
-            const wrapped = new ProgramSet(protos.Set);
+            const wrapped = new SetObj(builtins.Set);
             for (const item of value.values())
                 wrapped.set.add(next(item));
             return wrapped;
         }
         if (value instanceof URL)
-            return new ProgramURL(protos.URL, protos.URLSearchParams, new URL(value.href));
+            return new URLObj(builtins.URL, builtins.URLSearchParams, new URL(value.href));
         if (value instanceof URLSearchParams)
-            return new ProgramURLSearchParams(protos.URLSearchParams, new URLSearchParams(value));
+            return new URLSearchParamsObj(builtins.URLSearchParams, new URLSearchParams(value));
     }
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
     if (value instanceof Date)
         return Number.isFinite(value.getTime()) ? value.toISOString() : null;
-    if (value instanceof ProgramURL)
+    if (value instanceof URLObj)
         return value.url.href;
     if (value instanceof URL)
         return value.href;
-    if (boundary && protos === undefined) {
-        if (value instanceof ProgramRegExp)
+    if (value instanceof Bytes) {
+        if (boundary) {
+            throw new ToolRuntimeError("InvalidDataValue", `${label} contains a Uint8Array; pass text instead, e.g. \`new TextDecoder().decode(bytes)\` or \`bytes.toBase64()\`.`);
+        }
+        return Object.fromEntries(value.bytes.entries());
+    }
+    if (boundary && builtins === undefined) {
+        if (value instanceof RegExpObj)
             return String(value.regex);
-        if (value instanceof ProgramURLSearchParams)
+        if (value instanceof URLSearchParamsObj)
             return value.params.toString();
-        if (value instanceof ProgramSet) {
+        if (value instanceof SetObj) {
             if (seen.has(value))
                 throw new ToolRuntimeError("InvalidDataValue", `${label} contains a circular value.`);
             seen.add(value);
@@ -113,21 +119,21 @@ const copy = (value, label, mode, depth, seen, protos, boundary = true) => {
         value instanceof Map ||
         value instanceof Set ||
         value instanceof URLSearchParams) {
-        return protos !== undefined ? new ProgramObject(protos.Object) : {};
+        return builtins !== undefined ? new Obj(builtins.Object) : {};
     }
     if (seen.has(value)) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} contains a circular value.`);
     }
     seen.add(value);
-    if (value instanceof ProgramArray) {
+    if (value instanceof Arr) {
         const copied = Array.from(value.items, (item) => next(item) ?? null);
         seen.delete(value);
         return copied;
     }
-    if (value instanceof ProgramObject) {
+    if (value instanceof Obj) {
         const copied = {};
         // Errors serialize as { name, message, ...own }: both may be inherited, and neither is enumerable in JS.
-        if (value instanceof ProgramError) {
+        if (value instanceof ErrorObj) {
             defineHost(copied, "name", next(get(value, "name")));
             defineHost(copied, "message", next(get(value, "message")));
         }
@@ -143,8 +149,8 @@ const copy = (value, label, mode, depth, seen, protos, boundary = true) => {
         return copied;
     }
     if (Array.isArray(value)) {
-        if (protos !== undefined) {
-            const copied = new ProgramArray(protos.Array, value.map(next));
+        if (builtins !== undefined) {
+            const copied = new Arr(builtins.Array, value.map(next));
             for (const [key, item] of Object.entries(value)) {
                 if (parseArrayIndex(key) === undefined)
                     define(copied, key, next(item));
@@ -160,8 +166,8 @@ const copy = (value, label, mode, depth, seen, protos, boundary = true) => {
     if (prototype !== Object.prototype && prototype !== null) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain plain objects only.`);
     }
-    if (protos !== undefined) {
-        const copied = new ProgramObject(protos.Object);
+    if (builtins !== undefined) {
+        const copied = new Obj(builtins.Object);
         for (const [key, item] of Object.entries(value))
             define(copied, key, next(item));
         seen.delete(value);

package/dist/interpreter/callback.d.ts

@@ -0,0 +1,20 @@
+import { Effect } from "effect";
+import type { Interpreter } from "./interpreter.js";
+import { Callable } from "./objects.js";
+export type IteratorCursor<R> = {
+    readonly next: Effect.Effect<{
+        readonly done: boolean;
+        readonly value: unknown;
+    }, unknown, R>;
+    readonly close: Effect.Effect<void, unknown, R>;
+};
+export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
+/**
+ * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
+ * default hint as "string", like their `Symbol.toPrimitive`.
+ */
+export declare const toPrimitive: <R>(ctx: Interpreter<R>, value: unknown, hint: "number" | "string" | "default") => Effect.Effect<unknown, unknown, R>;
+export declare const toPrimitiveString: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<string, unknown, R>;
+export declare const toPrimitiveNumber: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<number, unknown, R>;
+export declare const isSupportedCallback: (value: unknown) => value is Callable;
+export declare const applyCollectionCallback: <R>(ctx: Interpreter<R>, callback: unknown, name: string) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);

package/dist/interpreter/{runner.js → callback.js}

@@ -1,7 +1,7 @@
 import { Effect, Exit } from "effect";
 import { coerceToNumber, coerceToString } from "../stdlib/value.js";
 import { typeError } from "./model.js";
-import { Callable, get, NativeFunction, ProgramDate, ProgramObject, ProgramPromise } from "./objects.js";
+import { Callable, get, Native, DateObj, Obj } from "./objects.js";
 import { typeofValue } from "./references.js";
 export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
     ? Effect.succeed(exit.value)
@@ -10,36 +10,36 @@ export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.e
  * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
  * default hint as "string", like their `Symbol.toPrimitive`.
  */
-export const toPrimitive = (runner, value, hint) => {
-    if (!(value instanceof ProgramObject))
+export const toPrimitive = (ctx, value, hint) => {
+    if (!(value instanceof Obj))
         return Effect.succeed(value);
-    const asString = hint === "string" || (hint === "default" && value instanceof ProgramDate);
+    const asString = hint === "string" || (hint === "default" && value instanceof DateObj);
     const order = asString ? ["toString", "valueOf"] : ["valueOf", "toString"];
     return Effect.gen(function* () {
         for (const method of order) {
             const callable = get(value, method);
             if (!(callable instanceof Callable))
                 continue;
-            const result = yield* runner.invokeCallable(callable, value, []);
+            const result = yield* ctx.call(callable, value, []);
             if (result === null || (typeof result !== "object" && typeof result !== "function"))
                 return result;
         }
         throw typeError("Cannot convert object to primitive value.");
     });
 };
-export const toPrimitiveString = (runner, value) => Effect.map(toPrimitive(runner, value, "string"), coerceToString);
-export const toPrimitiveNumber = (runner, value) => Effect.map(toPrimitive(runner, value, "number"), coerceToNumber);
+export const toPrimitiveString = (ctx, value) => Effect.map(toPrimitive(ctx, value, "string"), coerceToString);
+export const toPrimitiveNumber = (ctx, value) => Effect.map(toPrimitive(ctx, value, "number"), coerceToNumber);
 // The single acceptance list for callbacks: collections, sort, string replacers,
 // Array.from mappers, and promise reactions all admit exactly these callables.
 // Admission means dispatchable, not necessarily invocable: new-requiring
 // constructors pass the gate and throw a TypeError on call, like JS.
-export const isSupportedCallback = (value) => value instanceof Callable && !(value instanceof NativeFunction && !value.callback);
-export const applyCollectionCallback = (runner, callback, name) => {
+export const isSupportedCallback = (value) => value instanceof Callable && !(value instanceof Native && !value.callback);
+export const applyCollectionCallback = (ctx, callback, name) => {
     if (!isSupportedCallback(callback)) {
         if (typeofValue(callback) === "function") {
             throw typeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`);
         }
         throw typeError(`${name} expects a function callback.`);
     }
-    return (callbackArgs) => runner.invokeCallable(callback, undefined, callbackArgs);
+    return (callbackArgs) => ctx.call(callback, undefined, callbackArgs);
 };

package/dist/interpreter/errors.d.ts

@@ -1,8 +1,8 @@
 import type { Diagnostic } from "../codemode.js";
 import { type AstNode } from "./model.js";
 import { type ErrorType } from "./intrinsics.js";
-import { type NativeFunction, ProgramError, ProgramObject } from "./objects.js";
-import { type Runner } from "./runner.js";
+import { type Native, ErrorObj, Obj } from "./objects.js";
+import type { Interpreter } from "./interpreter.js";
 export declare const normalizeError: (error: unknown) => Diagnostic;
 /**
  * Gives a failure the source location of the expression that raised it, keeping the first one attached. Host errors
@@ -10,7 +10,7 @@ export declare const normalizeError: (error: unknown) => Diagnostic;
  */
 export declare const locate: (error: unknown, node?: AstNode) => unknown;
 /** The program value a handler receives for a failure; one failure always yields the same value. */
-export declare const materialize: <R>(runner: Runner<R>, thrown: unknown) => unknown;
-export declare const createAggregateErrorValue: <R>(runner: Runner<R>, errors: Array<unknown>, message: string, proto?: ProgramObject) => ProgramError;
+export declare const materialize: <R>(ctx: Interpreter<R>, thrown: unknown) => unknown;
+export declare const createAggregateErrorValue: <R>(ctx: Interpreter<R>, errors: Array<unknown>, message: string, proto?: Obj) => ErrorObj;
 /** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
-export declare const errorGlobal: <R>(type: ErrorType, runner: Runner<R>) => NativeFunction<R>;
+export declare const errorGlobal: <R>(type: ErrorType, ctx: Interpreter<R>) => Native<R>;

package/dist/interpreter/errors.js

@@ -1,12 +1,11 @@
 import { Effect } from "effect";
 import { ToolError } from "../tool-error.js";
 import { toData, ToolRuntimeError } from "../data.js";
-import { formatLocation, PendingThrow, ProgramThrow, sourceLocation, typeError } from "./model.js";
+import { formatLocation, PendingThrow, Throw, sourceLocation, typeError } from "./model.js";
 import { containsRuntimeReference } from "./references.js";
 import { createErrorValue, isErrorType } from "./intrinsics.js";
 import { constructor, methods, prototypeFrom, receiver } from "./native.js";
-import { define, get, hidden, ProgramArray, ProgramError, ProgramObject, } from "./objects.js";
-import {} from "./runner.js";
+import { define, get, hidden, Arr, ErrorObj, Obj } from "./objects.js";
 import { coerceToString } from "../stdlib/value.js";
 export const normalizeError = (error) => {
     if (error instanceof PendingThrow) {
@@ -27,9 +26,9 @@ export const normalizeError = (error) => {
     if (error instanceof ToolError) {
         return { kind: "ToolFailure", message: error.message };
     }
-    if (error instanceof ProgramThrow) {
+    if (error instanceof Throw) {
         const value = error.value;
-        if (value instanceof ProgramError) {
+        if (value instanceof ErrorObj) {
             return value.host ? normalizeError(value.host) : { kind: "ExecutionFailure", message: errorToString(value) };
         }
         let message;
@@ -83,19 +82,19 @@ export const locate = (error, node) => {
     return error;
 };
 /** The program value a handler receives for a failure; one failure always yields the same value. */
-export const materialize = (runner, thrown) => {
-    if (thrown instanceof ProgramThrow)
+export const materialize = (ctx, thrown) => {
+    if (thrown instanceof Throw)
         return thrown.value;
-    const prototypes = runner.prototypes;
+    const builtins = ctx.builtins;
     if (thrown instanceof PendingThrow) {
         if (thrown.value === undefined) {
-            thrown.value = createErrorValue(prototypes[thrown.type], thrown.message);
+            thrown.value = createErrorValue(builtins[thrown.type], thrown.message);
             thrown.value.host = thrown;
         }
         return thrown.value;
     }
     const type = thrown instanceof Error && isErrorType(thrown.name) ? thrown.name : "Error";
-    return createErrorValue(prototypes[type], normalizeError(thrown).message);
+    return createErrorValue(builtins[type], normalizeError(thrown).message);
 };
 /** Error.prototype.toString: `name: message`, omitting whichever side is empty. */
 const errorToString = (self) => {
@@ -109,43 +108,43 @@ const errorToString = (self) => {
         return shownMessage;
     return `${shownName}: ${shownMessage}`;
 };
-export const createAggregateErrorValue = (runner, errors, message, proto = runner.prototypes.AggregateError) => {
+export const createAggregateErrorValue = (ctx, errors, message, proto = ctx.builtins.AggregateError) => {
     const value = createErrorValue(proto, message);
-    define(value, "errors", new ProgramArray(runner.prototypes.Array, errors), { ...hidden });
+    define(value, "errors", new Arr(ctx.builtins.Array, errors), { ...hidden });
     return value;
 };
-const constructAggregateErrorValue = (runner, args, proto) => Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(args[0]);
+const constructAggregateErrorValue = (ctx, args, proto) => Effect.gen(function* () {
+    const cursor = yield* ctx.iterate(args[0]);
     if (cursor === undefined)
         throw typeError("new AggregateError(...) expects a synchronous iterable of errors.");
     const errors = [];
     while (true) {
         const step = yield* cursor.next;
         if (step.done) {
-            return createAggregateErrorValue(runner, errors, args[1] === undefined ? "" : coerceToString(args[1]), proto);
+            return createAggregateErrorValue(ctx, errors, args[1] === undefined ? "" : coerceToString(args[1]), proto);
         }
         errors.push(step.value);
     }
 });
 /** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
-export const errorGlobal = (type, runner) => {
-    const protos = runner.prototypes;
-    const prototype = protos[type];
+export const errorGlobal = (type, ctx) => {
+    const builtins = ctx.builtins;
+    const prototype = builtins[type];
     const construct = (args, newTarget) => {
         const proto = prototypeFrom(newTarget, prototype);
         return type === "AggregateError"
-            ? constructAggregateErrorValue(runner, args, proto)
+            ? constructAggregateErrorValue(ctx, args, proto)
             : Effect.sync(() => createErrorValue(proto, args[0] === undefined ? undefined : coerceToString(args[0])));
     };
-    const ctor = constructor(protos, prototype, {
+    const ctor = constructor(builtins, prototype, {
         name: type,
         length: type === "AggregateError" ? 2 : 1,
         call: (_, args) => construct(args, ctor),
         construct,
     });
     if (type === "Error") {
-        methods(protos, prototype, [
-            ["toString", 0, (thisValue) => errorToString(receiver(ProgramObject, thisValue, "Error.prototype.toString"))],
+        methods(builtins, prototype, [
+            ["toString", 0, (thisValue) => errorToString(receiver(Obj, thisValue, "Error.prototype.toString"))],
         ]);
     }
     return ctor;

package/dist/interpreter/execute.d.ts

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

package/dist/interpreter/execute.js

@@ -6,11 +6,11 @@ import { transpile } from "#transpile";
 import { toData } from "../data.js";
 import { ToolRuntime } from "../tool-runtime.js";
 import { normalizeError } from "./errors.js";
-import { createPrototypes } from "./intrinsics.js";
+import { createBuiltins } from "./intrinsics.js";
 import { PendingThrow } from "./model.js";
-import { PromiseRuntime } from "./promises.js";
-import { Runtime } from "./runtime.js";
-export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
+import { Pending } from "./promises.js";
+import { Interpreter } from "./interpreter.js";
+export const executeProgram = (code, prepared, limits, hooks, globals) => {
     if (code.trim().length === 0) {
         return Effect.succeed({
             ok: false,
@@ -20,19 +20,19 @@ export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
     }
     // Allocate execution state inside suspension so reused Effects never share it.
     return Effect.suspend(() => {
-        const prototypes = createPrototypes();
-        const tools = ToolRuntime.make(prepared, prototypes, limits.maxToolCalls, hooks);
+        const builtins = createBuiltins();
+        const tools = ToolRuntime.make(prepared, builtins, limits.maxToolCalls, hooks);
         const logs = [];
         const logged = () => (logs.length > 0 ? { logs: [...logs] } : {});
         // Set only after copy-out so timeouts cannot report invalid values as completed.
         let returned;
         const base = Effect.acquireUseRelease(Scope.make("parallel"), (scope) => Effect.gen(function* () {
             const program = parseProgram(code);
-            const promises = new PromiseRuntime(scope, prototypes.Promise);
-            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, prototypes, logs, extraGlobals).run(program);
+            const pending = new Pending(scope, builtins.Promise);
+            const value = yield* new Interpreter({ tools, pending, builtins, logs, globals }).run(program);
             const result = toData(value, "Execution result", "result");
-            returned = { value: result, promises };
-            const warnings = yield* promises.interrupt();
+            returned = { value: result, pending };
+            const warnings = yield* pending.interrupt();
             return {
                 ok: true,
                 value: result,
@@ -64,7 +64,7 @@ export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
                                 kind: "TimeoutExceeded",
                                 message: `The program returned, but background work was still running at the ${timeoutMs}ms timeout and was interrupted. Await all started promises.`,
                             },
-                            ...returned.promises.diagnostics(),
+                            ...returned.pending.diagnostics(),
                         ],
                         ...logged(),
                         toolCalls: tools.calls,

package/dist/interpreter/extensions.d.ts

@@ -1,8 +1,8 @@
 import type { Extension } from "../extension.js";
-import type { Host } from "./globals.js";
+import type { Interpreter } from "./interpreter.js";
 /**
  * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data is
  * copied, built-in wrappers are copied, instances of exposed classes travel as handles, and a host Promise becomes
  * a program promise. Prototypes, constructors, and handle identity are all per run.
  */
-export declare const extensionGlobals: <R>(host: Host<R>, extensions: ReadonlyArray<Extension>) => ReadonlyArray<readonly [string, unknown]>;
+export declare const extensionGlobals: <R>(ctx: Interpreter<R>, extensions: ReadonlyArray<Extension>) => ReadonlyArray<readonly [string, unknown]>;