@opencode/codemode 0.0.0-dev-19530 → 2.0.0

package/dist/data.d.ts

@@ -1,22 +1,21 @@
 export * as Data from "./data.js";
 import type { DiagnosticKind } from "./codemode.js";
-import type { Prototypes } from "./interpreter/intrinsics.js";
 export declare class ToolRuntimeError extends Error {
     readonly kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">;
     readonly suggestions: ReadonlyArray<string>;
     constructor(kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded">, message: string, suggestions?: ReadonlyArray<string>);
 }
 /**
- * Brings a host-produced value into the program: program values pass through, host Date, RegExp,
- * Map, Set, URL, and URLSearchParams become their built-in wrappers, and host objects and arrays
- * are copied.
+ * Brings a host-produced value into the program: program and runtime values pass through, their
+ * host counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and host objects
+ * and arrays are copied.
  */
-export declare const toProgram: (protos: Prototypes, value: unknown, label: string) => unknown;
+export declare const toProgram: (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: (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,6 @@
 export * as Data from "./data.js";
-import { Callable, define, entries, get, isWrapper, parseArrayIndex, ProgramArray, ProgramDate, ProgramError, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./interpreter/objects.js";
+import { ownEntries, parseArrayIndex, ProgramArray, ProgramFunction, ProgramObject, set, } from "./interpreter/objects.js";
+import { Values } from "./values.js";
 const MAX_VALUE_DEPTH = 32;
 export class ToolRuntimeError extends Error {
     kind;
@@ -12,16 +13,16 @@ export class ToolRuntimeError extends Error {
     }
 }
 /**
- * Brings a host-produced value into the program: program values pass through, host Date, RegExp,
- * Map, Set, URL, and URLSearchParams become their built-in wrappers, and host objects and arrays
- * are copied.
+ * Brings a host-produced value into the program: program and runtime values pass through, their
+ * host counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and host objects
+ * and arrays are copied.
  */
-export const toProgram = (protos, value, label) => copy(value, label, "program", 0, new Set(), protos);
+export const toProgram = (value, label) => copy(value, label, "program", 0, new Set());
 /**
  * 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 = (value, label) => copy(value, label, "data", 0, new Set());
 /**
  * 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
@@ -29,8 +30,7 @@ export const fromData = (protos, value, label) => copy(value, label, "data", 0,
  * undefined); a bare `undefined` follows the same rule.
  */
 export const toData = (value, label, undefinedAs = "json") => copy(value, label, undefinedAs, 0, new Set());
-const copy = (value, label, mode, depth, seen, protos) => {
-    const next = (item) => copy(item, label, mode, depth + 1, seen, protos);
+const copy = (value, label, mode, depth, seen) => {
     if (depth > MAX_VALUE_DEPTH) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
     }
@@ -43,88 +43,85 @@ const copy = (value, label, mode, depth, seen, protos) => {
     if (typeof value !== "object") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
     }
-    if (value instanceof ProgramPromise) {
+    if (value instanceof Values.Promise) {
         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 ProgramFunction && mode !== "program") {
         throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
     }
-    if (protos !== undefined && mode === "program") {
-        if (value instanceof ProgramObject)
+    const plain = mode === "program" || mode === "data";
+    if (mode === "program") {
+        if (value instanceof ProgramObject || Values.isValue(value))
             return value;
         if (value instanceof Date)
-            return new ProgramDate(protos.Date, value.getTime());
+            return new Values.Date(value.getTime());
         if (value instanceof RegExp)
-            return new ProgramRegExp(protos.RegExp, value.source, value.flags);
+            return new Values.RegExp(value.source, value.flags);
         if (value instanceof Map) {
-            const wrapped = new ProgramMap(protos.Map);
-            for (const [key, item] of value.entries())
-                wrapped.map.set(next(key), next(item));
+            const wrapped = new Values.Map();
+            for (const [key, item] of value.entries()) {
+                wrapped.map.set(copy(key, label, mode, depth + 1, seen), copy(item, label, mode, depth + 1, seen));
+            }
             return wrapped;
         }
         if (value instanceof Set) {
-            const wrapped = new ProgramSet(protos.Set);
+            const wrapped = new Values.Set();
             for (const item of value.values())
-                wrapped.set.add(next(item));
+                wrapped.set.add(copy(item, label, mode, depth + 1, seen));
             return wrapped;
         }
         if (value instanceof URL)
-            return new ProgramURL(protos.URL, protos.URLSearchParams, new URL(value.href));
+            return new Values.URL(new URL(value.href));
         if (value instanceof URLSearchParams)
-            return new ProgramURLSearchParams(protos.URLSearchParams, new URLSearchParams(value));
+            return new Values.URLSearchParams(new URLSearchParams(value));
     }
-    if (value instanceof ProgramDate)
+    if (value instanceof Values.Date)
         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 Values.URL)
         return value.url.href;
     if (value instanceof URL)
         return value.href;
-    // Remaining wrappers and their host counterparts serialize as empty objects, like JSON.stringify.
-    if (isWrapper(value) ||
+    // Remaining runtime values and their host counterparts serialize as empty objects, like JSON.stringify.
+    if (Values.isValue(value) ||
         value instanceof RegExp ||
         value instanceof Map ||
         value instanceof Set ||
         value instanceof URLSearchParams) {
-        return protos !== undefined ? new ProgramObject(protos.Object) : {};
+        return plain ? new ProgramObject() : {};
     }
     if (seen.has(value)) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} contains a circular value.`);
     }
     seen.add(value);
     if (value instanceof ProgramArray) {
-        const copied = Array.from(value.items, (item) => next(item) ?? null);
+        const copied = Array.from(value.items, (item) => copy(item, label, mode, depth + 1, seen) ?? null);
         seen.delete(value);
         return copied;
     }
     if (value instanceof ProgramObject) {
         const copied = {};
-        // Errors serialize as { name, message, ...own }: both may be inherited, and neither is enumerable in JS.
-        if (value instanceof ProgramError) {
-            defineHost(copied, "name", next(get(value, "name")));
-            defineHost(copied, "message", next(get(value, "message")));
-        }
-        for (const [key, item] of entries(value)) {
-            const copiedItem = next(item);
-            if (copiedItem === undefined && mode === "json")
+        for (const [key, item] of ownEntries(value)) {
+            const next = copy(item, label, mode, depth + 1, seen);
+            if (next === undefined && mode === "json")
                 continue;
-            defineHost(copied, key, copiedItem);
+            define(copied, key, next);
         }
         seen.delete(value);
         return copied;
     }
     if (Array.isArray(value)) {
-        if (protos !== undefined) {
-            const copied = new ProgramArray(protos.Array, value.map(next));
+        if (plain) {
+            const copied = new ProgramArray(value.map((item) => copy(item, label, mode, depth + 1, seen)));
             for (const [key, item] of Object.entries(value)) {
                 if (parseArrayIndex(key) === undefined)
-                    define(copied, key, next(item));
+                    set(copied, key, copy(item, label, mode, depth + 1, seen));
             }
             seen.delete(value);
             return copied;
         }
-        const copied = Array.from(value, (item) => next(item) ?? null);
+        const copied = Array.from(value, (item) => copy(item, label, mode, depth + 1, seen) ?? null);
         seen.delete(value);
         return copied;
     }
@@ -132,25 +129,25 @@ const copy = (value, label, mode, depth, seen, protos) => {
     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 (plain) {
+        const copied = new ProgramObject();
         for (const [key, item] of Object.entries(value))
-            define(copied, key, next(item));
+            set(copied, key, copy(item, label, mode, depth + 1, seen));
         seen.delete(value);
         return copied;
     }
     const copied = {};
     for (const [key, item] of Object.entries(value)) {
-        const copiedItem = next(item);
-        if (copiedItem === undefined && mode === "json")
+        const next = copy(item, label, mode, depth + 1, seen);
+        if (next === undefined && mode === "json")
             continue;
-        defineHost(copied, key, copiedItem);
+        define(copied, key, next);
     }
     seen.delete(value);
     return copied;
 };
 // Own data property regardless of the target's prototype, so a "__proto__" key on a host object
 // never reaches the Object.prototype setter.
-const defineHost = (target, key, value) => {
+const define = (target, key, value) => {
     Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
 };

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export * as CodeMode from "./codemode.js";
 export * as Namespace from "./namespace.js";
 export * as Tool from "./tool.js";
 export * as OpenAPI from "./openapi/index.js";
+export { Values } from "./values.js";
 export { searchSignature, toolExpression } from "./codemode.js";
 export { ToolError, toolError } from "./tool-error.js";

package/dist/index.js

@@ -2,5 +2,6 @@ export * as CodeMode from "./codemode.js";
 export * as Namespace from "./namespace.js";
 export * as Tool from "./tool.js";
 export * as OpenAPI from "./openapi/index.js";
+export { Values } from "./values.js";
 export { searchSignature, toolExpression } from "./codemode.js";
 export { ToolError, toolError } from "./tool-error.js";

package/dist/interpreter/errors.d.ts

@@ -1,9 +1,7 @@
 import type { Diagnostic } from "../codemode.js";
-import { type ErrorType } from "./intrinsics.js";
-import { type NativeFunction, ProgramError, ProgramObject } from "./objects.js";
+import { HostFunction } from "./host.js";
 import { type Runner } from "./runner.js";
 export declare const normalizeError: (error: unknown) => Diagnostic;
-export declare const caughtErrorValue: <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 caughtErrorValue: (thrown: unknown) => unknown;
 /** 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>(name: string, runner: Runner<R>) => HostFunction<R>;

package/dist/interpreter/errors.js

@@ -3,11 +3,10 @@ import { ToolError } from "../tool-error.js";
 import { toData, ToolRuntimeError } from "../data.js";
 import { formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } 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 { HostFunction } from "./host.js";
+import { get, ProgramError, ProgramObject } from "./objects.js";
 import {} from "./runner.js";
-import { coerceToString } from "../stdlib/value.js";
+import { coerceToString, createAggregateErrorValue, createErrorValue, errorBrandName, errorConstructors, } from "../stdlib/value.js";
 export const normalizeError = (error) => {
     if (error instanceof InterpreterRuntimeError) {
         return {
@@ -67,69 +66,41 @@ export const normalizeError = (error) => {
         message: String(error),
     };
 };
-export const caughtErrorValue = (runner, thrown) => {
+export const caughtErrorValue = (thrown) => {
     if (thrown instanceof ProgramThrow)
         return thrown.value;
-    const prototypes = runner.prototypes;
     if (thrown instanceof InterpreterRuntimeError)
-        return createErrorValue(prototypes[thrown.type], thrown.message);
-    const type = thrown instanceof Error && isErrorType(thrown.name) ? thrown.name : "Error";
-    return createErrorValue(prototypes[type], normalizeError(thrown).message);
+        return createErrorValue(thrown.errorName, thrown.message);
+    const name = thrown instanceof Error && errorConstructors.has(thrown.name) ? thrown.name : "Error";
+    return createErrorValue(name, normalizeError(thrown).message);
 };
-export const createAggregateErrorValue = (runner, errors, message, proto = runner.prototypes.AggregateError) => {
-    const value = createErrorValue(proto, message);
-    define(value, "errors", new ProgramArray(runner.prototypes.Array, errors), { ...hidden });
-    return value;
-};
-const constructAggregateErrorValue = (runner, args, proto, node) => Effect.gen(function* () {
+const constructErrorValue = (name, args) => createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]));
+const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function* () {
     const cursor = yield* runner.syncIterator(args[0], node);
     if (cursor === undefined) {
-        throw new InterpreterRuntimeError("new AggregateError(...) expects a synchronous iterable of errors.", node);
+        throw new InterpreterRuntimeError("new AggregateError(...) expects a synchronous iterable of errors.", node).as("TypeError");
     }
     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(errors, args[1] === undefined ? "" : coerceToString(args[1]));
         }
         errors.push(step.value);
     }
 });
 /** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
-export const errorGlobal = (type, runner) => {
-    const protos = runner.prototypes;
-    const prototype = protos[type];
-    const construct = (args, newTarget, node) => {
-        const proto = prototypeFrom(newTarget, prototype);
-        return type === "AggregateError"
-            ? constructAggregateErrorValue(runner, args, proto, node)
-            : Effect.sync(() => createErrorValue(proto, args[0] === undefined ? undefined : coerceToString(args[0])));
-    };
-    const ctor = constructor(protos, prototype, {
-        name: type,
-        length: type === "AggregateError" ? 2 : 1,
-        call: (_, args, node) => construct(args, ctor, node),
+export const errorGlobal = (name, runner) => {
+    const construct = (args, node) => name === "AggregateError"
+        ? constructAggregateErrorValue(runner, args, node)
+        : Effect.sync(() => constructErrorValue(name, args));
+    return new HostFunction({
+        name,
+        call: construct,
         construct,
+        instanceOf: (value) => {
+            const brand = errorBrandName(value);
+            return brand !== undefined && (name === "Error" || brand === name);
+        },
     });
-    if (type === "Error") {
-        methods(protos, prototype, [
-            [
-                "toString",
-                0,
-                (thisValue, _, node) => {
-                    const self = receiver(ProgramObject, thisValue, "Error.prototype.toString", node);
-                    const name = get(self, "name");
-                    const message = get(self, "message");
-                    const shownName = name === undefined ? "Error" : coerceToString(name);
-                    const shownMessage = message === undefined ? "" : coerceToString(message);
-                    if (shownMessage === "")
-                        return shownName;
-                    if (shownName === "")
-                        return shownMessage;
-                    return `${shownName}: ${shownMessage}`;
-                },
-            ],
-        ]);
-    }
-    return ctor;
 };

package/dist/interpreter/execute.js

@@ -6,7 +6,6 @@ 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 { InterpreterRuntimeError } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
 import { Runtime } from "./runtime.js";
@@ -20,16 +19,15 @@ 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 tools = ToolRuntime.make(prepared, limits.maxToolCalls, hooks);
         const logs = [];
         const logged = () => (logs.length > 0 ? { logs: [...logs] } : {});
         // Set only after copy-out so timeouts cannot report invalid values as completed.
         let returned;
         const base = Effect.acquireUseRelease(Scope.make("parallel"), (scope) => Effect.gen(function* () {
             const program = parseProgram(code);
-            const promises = new PromiseRuntime(scope, prototypes.Promise);
-            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, prototypes, logs, extraGlobals).run(program);
+            const promises = new PromiseRuntime(scope);
+            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, logs, extraGlobals).run(program);
             const result = toData(value, "Execution result", "result");
             returned = { value: result, promises };
             const warnings = yield* promises.interrupt();

package/dist/interpreter/globals.js

@@ -5,81 +5,59 @@ import { consoleGlobal } from "../stdlib/console.js";
 import { dateGlobal } from "../stdlib/date.js";
 import { jsonGlobal } from "../stdlib/json.js";
 import { mathGlobal } from "../stdlib/math.js";
-import { booleanGlobal, numberGlobal } from "../stdlib/number.js";
+import { numberGlobal } from "../stdlib/number.js";
 import { objectGlobal } from "../stdlib/object.js";
 import { regexpGlobal } from "../stdlib/regexp.js";
 import { stringGlobal } from "../stdlib/string.js";
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js";
-import { coercion } from "../stdlib/value.js";
-import { base64Global, cryptoGlobal } from "../stdlib/web.js";
+import { coercion, errorConstructors } from "../stdlib/value.js";
+import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js";
 import { ToolReference } from "../tool-runtime.js";
 import { errorGlobal } from "./errors.js";
-import { errorTypes } from "./intrinsics.js";
-import { constants, constructor, native } from "./native.js";
+import { HostFunction } from "./host.js";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "./model.js";
-import { generatorGlobals } from "./generators.js";
 import { promiseGlobal } from "./promises.js";
-// Function.prototype.constructor exists so `fn.constructor === Function` holds; dynamic code is unsupported.
-const functionGlobal = (runner) => {
-    const reject = (_, __, node) => Effect.sync(() => {
-        throw new InterpreterRuntimeError("The Function constructor is not supported; write the function inline.", node);
-    });
-    return constructor(runner.prototypes, runner.prototypes.Function, {
-        name: "Function",
-        length: 1,
-        call: reject,
-        construct: (args, _, node) => reject(undefined, args, node),
-    });
-};
-const symbolGlobal = (runner) => {
-    const symbol = native(runner.prototypes, {
-        name: "Symbol",
-        call: (_, __, node) => Effect.sync(() => {
-            throw new InterpreterRuntimeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.", node);
-        }),
-        callback: false,
-    });
-    constants(symbol, { asyncIterator: AsyncIteratorSymbol, iterator: IteratorSymbol });
-    return symbol;
-};
+const symbolGlobal = new HostFunction({
+    name: "Symbol",
+    call: (_, node) => Effect.sync(() => {
+        throw new InterpreterRuntimeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.", node).as("TypeError");
+    }),
+    callback: false,
+    members: { asyncIterator: AsyncIteratorSymbol, iterator: IteratorSymbol },
+});
 /** The immutable global bindings of every program, in declaration order. */
-export const globals = (host) => {
-    const runner = host.runner;
-    generatorGlobals(runner, host.promises);
-    return [
-        ["tools", new ToolReference([])],
-        ["search", native(runner.prototypes, { name: "search", call: (_, args) => host.search(args), callback: false })],
-        ["undefined", undefined],
-        ["NaN", NaN],
-        ["Infinity", Infinity],
-        ["Object", objectGlobal(runner, host.toolKeys)],
-        ["Function", functionGlobal(runner)],
-        ["Array", arrayGlobal(runner)],
-        ["Math", mathGlobal(runner)],
-        ["JSON", jsonGlobal(runner)],
-        ["console", consoleGlobal(runner, host.logs)],
-        ["Promise", promiseGlobal(runner, host.promises)],
-        ["Symbol", symbolGlobal(runner)],
-        ["Number", numberGlobal(runner)],
-        ["String", stringGlobal(runner)],
-        ["Boolean", booleanGlobal(runner)],
-        ["parseInt", coercion(runner, "parseInt", 2)],
-        ["parseFloat", coercion(runner, "parseFloat")],
-        ["isFinite", coercion(runner, "isFinite")],
-        ["isNaN", coercion(runner, "isNaN")],
-        ["Date", dateGlobal(runner)],
-        ["RegExp", regexpGlobal(runner)],
-        ["Map", mapGlobal(runner)],
-        ["Set", setGlobal(runner)],
-        ["URL", urlGlobal(runner)],
-        ["URLSearchParams", urlSearchParamsGlobal(runner)],
-        ["encodeURI", uriGlobal(runner, "encodeURI")],
-        ["encodeURIComponent", uriGlobal(runner, "encodeURIComponent")],
-        ["decodeURI", uriGlobal(runner, "decodeURI")],
-        ["decodeURIComponent", uriGlobal(runner, "decodeURIComponent")],
-        ["atob", base64Global(runner, "atob")],
-        ["btoa", base64Global(runner, "btoa")],
-        ["crypto", cryptoGlobal(runner)],
-        ...errorTypes.map((type) => [type, errorGlobal(type, runner)]),
-    ];
-};
+export const globals = (host) => [
+    ["tools", new ToolReference([])],
+    ["search", new HostFunction({ name: "search", call: (args) => host.search(args), callback: false })],
+    ["undefined", undefined],
+    ["NaN", NaN],
+    ["Infinity", Infinity],
+    ["Object", objectGlobal(host.runner, host.toolKeys)],
+    ["Array", arrayGlobal(host.runner)],
+    ["Math", mathGlobal(host.runner)],
+    ["JSON", jsonGlobal(host.runner)],
+    ["console", consoleGlobal(host.logs)],
+    ["Promise", promiseGlobal(host.runner, host.promises)],
+    ["Symbol", symbolGlobal],
+    ["Number", numberGlobal],
+    ["String", stringGlobal],
+    ["Boolean", coercion("Boolean", { instanceOf: () => false })],
+    ["parseInt", coercion("parseInt")],
+    ["parseFloat", coercion("parseFloat")],
+    ["isFinite", coercion("isFinite")],
+    ["isNaN", coercion("isNaN")],
+    ["Date", dateGlobal(host.runner)],
+    ["RegExp", regexpGlobal],
+    ["Map", mapGlobal(host.runner)],
+    ["Set", setGlobal(host.runner)],
+    ["URL", urlGlobal],
+    ["URLSearchParams", urlSearchParamsGlobal(host.runner)],
+    ["encodeURI", uriGlobal("encodeURI")],
+    ["encodeURIComponent", uriGlobal("encodeURIComponent")],
+    ["decodeURI", uriGlobal("decodeURI")],
+    ["decodeURIComponent", uriGlobal("decodeURIComponent")],
+    ["atob", atobGlobal],
+    ["btoa", btoaGlobal],
+    ["crypto", cryptoGlobal],
+    ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)]),
+];

package/dist/interpreter/host.d.ts

@@ -0,0 +1,41 @@
+import { Effect } from "effect";
+import { type AstNode } from "./model.js";
+export type HostCall<R> = (args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+type HostMember = (key: PropertyKey, node: AstNode) => unknown;
+type HostFunctionOptions<R> = {
+    readonly name: string;
+    readonly call: HostCall<R>;
+    /** `new name(...)`; without it `new` is unsupported syntax. */
+    readonly construct?: HostCall<R>;
+    /** Static members read through `name.key`; unknown keys read as `undefined` unless the function decides otherwise. */
+    readonly members?: Record<string, unknown> | HostMember;
+    /** `value instanceof name`; without it the operator rejects this right-hand side. */
+    readonly instanceOf?: (value: unknown) => boolean;
+    /** Whether callback sites (array methods, replacers, promise reactions) admit this function. Defaults to true. */
+    readonly callback?: boolean;
+};
+/** A host-implemented function value. `typeof` is "function". */
+export declare class HostFunction<R = never> {
+    readonly name: string;
+    readonly call: HostCall<R>;
+    readonly construct: HostCall<R> | undefined;
+    readonly member: HostMember;
+    readonly instanceOf: ((value: unknown) => boolean) | undefined;
+    readonly callback: boolean;
+    constructor(options: HostFunctionOptions<R>);
+}
+/** A host-implemented object of static members. `typeof` is "object" and it is not callable. */
+export declare class HostNamespace {
+    readonly name: string;
+    readonly member: HostMember;
+    constructor(name: string, members: Record<string, unknown> | HostMember);
+}
+export type SyncOptions = Omit<HostFunctionOptions<never>, "name" | "call">;
+type SyncImpl = (args: Array<unknown>, node: AstNode) => unknown;
+/** Lifts a synchronous implementation, which may throw `InterpreterRuntimeError`, into a host call. */
+export declare const syncCall: (impl: SyncImpl) => HostCall<never>;
+/** A synchronous host function. */
+export declare const sync: (name: string, impl: SyncImpl, options?: SyncOptions) => HostFunction<never>;
+/** The `call` of a constructor that JS requires to be invoked with `new`. */
+export declare const requiresNew: (name: string) => HostCall<never>;
+export {};

package/dist/interpreter/host.js

@@ -0,0 +1,44 @@
+import { Effect } from "effect";
+import { InterpreterRuntimeError } from "./model.js";
+/** A host-implemented function value. `typeof` is "function". */
+export class HostFunction {
+    name;
+    call;
+    construct;
+    member;
+    instanceOf;
+    callback;
+    constructor(options) {
+        this.name = options.name;
+        this.call = options.call;
+        this.construct = options.construct;
+        this.member = memberLookup(options.members);
+        this.instanceOf = options.instanceOf;
+        this.callback = options.callback ?? true;
+    }
+}
+/** A host-implemented object of static members. `typeof` is "object" and it is not callable. */
+export class HostNamespace {
+    name;
+    member;
+    constructor(name, members) {
+        this.name = name;
+        this.member = memberLookup(members);
+    }
+}
+const memberLookup = (members) => {
+    if (members === undefined)
+        return () => undefined;
+    if (typeof members === "function")
+        return members;
+    const table = new Map(Object.entries(members));
+    return (key) => (typeof key === "string" ? table.get(key) : undefined);
+};
+/** Lifts a synchronous implementation, which may throw `InterpreterRuntimeError`, into a host call. */
+export const syncCall = (impl) => (args, node) => Effect.sync(() => impl(args, node));
+/** A synchronous host function. */
+export const sync = (name, impl, options = {}) => new HostFunction({ name, call: syncCall(impl), ...options });
+/** The `call` of a constructor that JS requires to be invoked with `new`. */
+export const requiresNew = (name) => (_, node) => Effect.sync(() => {
+    throw new InterpreterRuntimeError(`Constructor ${name} requires 'new'.`, node).as("TypeError");
+});

package/dist/interpreter/methods.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { type AstNode, IntrinsicReference } from "./model.js";
+import { type Runner } from "./runner.js";
+export declare const invokeIntrinsic: <R>(runner: Runner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;