@opencode/codemode 0.0.0-beta-19296 → 0.0.0-beta-19378

package/README.md

@@ -91,6 +91,12 @@ runtime.execute(source) // Effect<CodeMode.Result, never, ToolServices>
 The Effect environment is inferred from the supplied tools. `onToolCallStart` observes admitted calls with decoded
 input; `onToolCallEnd` observes settled outcomes and duration. Both hooks return Effects and must not fail.
 
+### `Values`
+
+`Values` exports the runtime's non-JSON value classes: `Values.URL`, `Values.URLSearchParams`, `Values.Date`,
+`Values.RegExp`, `Values.Map`, `Values.Set`, and `Values.Promise`. The interpreter recognizes these by class; a
+program's `new URL(...)` is a `Values.URL` wrapping the host `URL`. `Values.isValue` narrows to the data-like kinds.
+
 ### OpenAPI tools
 
 `OpenAPI.fromSpec` converts an OpenAPI 3.x document into one tool per supported operation. Dotted `operationId` values

package/dist/codemode.d.ts

@@ -25,23 +25,20 @@ export type ResolvedExecutionLimits = {
     readonly maxToolCalls: number | undefined;
     readonly maxOutputBytes: number | undefined;
 };
-/** Options for one CodeMode execution. */
-export type ExecuteOptions<Provided extends Record<string, unknown> = {}> = {
-    /** Source for one program in the supported JavaScript subset. */
-    code: string;
+/** Configuration shared by `CodeMode.make` and `CodeMode.execute`. */
+export type Options<Provided extends Record<string, unknown> = {}> = ToolRuntime.ToolCallHooks<Services<Provided>> & {
     /** Explicit tools exposed to the program as `tools`. */
     tools?: Provided & Tools<Services<Provided>>;
-    /** Per-execution overrides for the default resource limits. */
+    /** Resource limits enforced on each execution. */
     limits?: ExecutionLimits;
-    /** Observes decoded tool input immediately before tool execution. */
-    onToolCallStart?: (call: ToolRuntime.ToolCallStarted) => Effect.Effect<void, never, Services<Provided>>;
-    /** Observes each admitted tool call as it succeeds, fails, or is interrupted. */
-    onToolCallEnd?: (call: ToolRuntime.ToolCallEnded) => Effect.Effect<void, never, Services<Provided>>;
+};
+/** Options for one CodeMode execution. */
+export type ExecuteOptions<Provided extends Record<string, unknown> = {}> = Options<Provided> & {
+    /** Source for one program in the supported JavaScript subset. */
+    code: string;
 };
 /** A JSON value that can cross the confined interpreter boundary. */
 export type DataValue = Schema.Json;
-/** Configuration shared by `CodeMode.make` and `CodeMode.execute`. */
-export type Options<Provided extends Record<string, unknown> = {}> = Omit<ExecuteOptions<Provided>, "code">;
 /** Schema for a host tool input containing CodeMode source. */
 export declare const Input: Schema.Struct<{
     readonly code: Schema.String;

package/dist/codemode.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { executeWithLimits } from "./interpreter/execute.js";
+import { executeProgram } from "./interpreter/execute.js";
 import { ToolRuntime } from "./tool-runtime.js";
 /** Signature-construction helpers for host-owned catalog instructions. */
 export { searchSignature, toolExpression } from "./tool-runtime.js";
@@ -54,17 +54,13 @@ const resolveExecutionLimits = (limits) => ({
     maxOutputBytes: validateLimit("maxOutputBytes", limits?.maxOutputBytes, 0),
 });
 /** Executes one Effect-native CodeMode program without constructing a reusable runtime. */
-export const execute = (options) => {
-    const tools = (options.tools ?? {});
-    return executeWithLimits(options, resolveExecutionLimits(options.limits), ToolRuntime.searchIndex(tools));
-};
+export const execute = (options) => make(options).execute(options.code);
 /** Creates an Effect-native runtime over explicit, schema-described tools. */
 export const make = (options = {}) => {
-    const tools = (options.tools ?? {});
+    const prepared = ToolRuntime.prepare((options.tools ?? {}));
     const limits = resolveExecutionLimits(options.limits);
-    const prepared = ToolRuntime.prepare(tools);
     return {
         catalog: () => prepared.catalog,
-        execute: (code) => executeWithLimits({ ...options, code }, limits, prepared.searchIndex),
+        execute: (code) => executeProgram(code, prepared, limits, options),
     };
 };

package/dist/data.d.ts

@@ -0,0 +1,28 @@
+export * as Data from "./data.js";
+import type { DiagnosticKind } from "./codemode.js";
+/** A null-prototype object owned by the program. */
+export type SafeObject = Record<string, unknown>;
+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>);
+}
+export declare const isBlockedMember: (name: string) => boolean;
+/**
+ * Brings a host-produced runtime value into the program: runtime values pass through, their host
+ * counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and objects become
+ * null-prototype copies. Arrays keep extra enumerable properties such as `index` and `groups`.
+ */
+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 null-prototype copies. Used for tool results and parsed JSON.
+ */
+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
+ * dropped ("json") or become null ("result", for program results where the consumer must never see
+ * undefined); a bare `undefined` follows the same rule.
+ */
+export declare const toData: (value: unknown, label: string, undefinedAs?: "json" | "result") => unknown;

package/dist/data.js

@@ -0,0 +1,130 @@
+export * as Data from "./data.js";
+import { Values } from "./values.js";
+const MAX_VALUE_DEPTH = 32;
+export class ToolRuntimeError extends Error {
+    kind;
+    suggestions;
+    constructor(kind, message, suggestions = []) {
+        super(message);
+        this.kind = kind;
+        this.suggestions = suggestions;
+        this.name = "ToolRuntimeError";
+    }
+}
+const blockedMemberNames = new Set(["__proto__", "constructor", "prototype"]);
+export const isBlockedMember = (name) => blockedMemberNames.has(name);
+/**
+ * Brings a host-produced runtime value into the program: runtime values pass through, their host
+ * counterparts (Date, RegExp, Map, Set, URL, URLSearchParams) are wrapped, and objects become
+ * null-prototype copies. Arrays keep extra enumerable properties such as `index` and `groups`.
+ */
+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 null-prototype copies. Used for tool results and parsed JSON.
+ */
+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
+ * dropped ("json") or become null ("result", for program results where the consumer must never see
+ * 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) => {
+    if (depth > MAX_VALUE_DEPTH) {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
+    }
+    if (value === undefined)
+        return mode === "result" ? null : undefined;
+    if (typeof value === "number")
+        return (mode === "json" || mode === "result") && !Number.isFinite(value) ? null : value;
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value !== "object") {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
+    }
+    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 (mode === "program") {
+        if (Values.isValue(value))
+            return value;
+        if (value instanceof Date)
+            return new Values.Date(value.getTime());
+        if (value instanceof RegExp)
+            return new Values.RegExp(value.source, value.flags);
+        if (value instanceof Map) {
+            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 Values.Set();
+            for (const item of value.values())
+                wrapped.set.add(copy(item, label, mode, depth + 1, seen));
+            return wrapped;
+        }
+        if (value instanceof URL)
+            return new Values.URL(new URL(value.href));
+        if (value instanceof URLSearchParams)
+            return new Values.URLSearchParams(new URLSearchParams(value));
+    }
+    const plain = mode === "program" || mode === "data";
+    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 Values.URL)
+        return value.url.href;
+    if (value instanceof URL)
+        return value.href;
+    // 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 plain ? Object.create(null) : {};
+    }
+    if (seen.has(value)) {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} contains a circular value.`);
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        // Host output densifies holes to null like JSON; program copies keep them.
+        const copied = plain
+            ? value.map((item) => copy(item, label, mode, depth + 1, seen))
+            : Array.from(value, (item) => copy(item, label, mode, depth + 1, seen) ?? null);
+        if (mode === "program") {
+            for (const [key, item] of Object.entries(value)) {
+                if (Object.hasOwn(copied, key))
+                    continue;
+                if (isBlockedMember(key)) {
+                    throw new ToolRuntimeError("InvalidDataValue", `${label} contains blocked property '${key}'.`);
+                }
+                Reflect.set(copied, key, copy(item, label, mode, depth + 1, seen));
+            }
+        }
+        seen.delete(value);
+        return copied;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} must contain plain objects only.`);
+    }
+    const copied = plain ? Object.create(null) : {};
+    for (const [key, item] of Object.entries(value)) {
+        if (isBlockedMember(key)) {
+            throw new ToolRuntimeError("InvalidDataValue", `${label} contains blocked property '${key}'.`);
+        }
+        const next = copy(item, label, mode, depth + 1, seen);
+        if (next === undefined && mode === "json")
+            continue;
+        copied[key] = next;
+    }
+    seen.delete(value);
+    return copied;
+};

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 { Effect } from "effect";
 import type { Diagnostic } from "../codemode.js";
-import { type SafeObject } from "../tool-runtime.js";
-import { type AstNode } from "./model.js";
-import { type SyncIteratorRunner } from "./iterator.js";
+import { HostFunction } from "./host.js";
+import { type Runner } from "./runner.js";
 export declare const normalizeError: (error: unknown) => Diagnostic;
 export declare const caughtErrorValue: (thrown: unknown) => unknown;
-export declare const constructErrorValue: (name: string, args: Array<unknown>) => SafeObject;
-export declare const constructAggregateErrorValue: <R>(runner: SyncIteratorRunner<R>, args: Array<unknown>, node: AstNode) => Effect.Effect<SafeObject, unknown, R>;
+/** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
+export declare const errorGlobal: <R>(name: string, runner: Runner<R>) => HostFunction<R>;

package/dist/interpreter/errors.js

@@ -1,10 +1,11 @@
 import { Effect } from "effect";
 import { ToolError } from "../tool-error.js";
-import { copyOut, ToolRuntimeError } from "../tool-runtime.js";
+import { toData, ToolRuntimeError } from "../data.js";
 import { formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js";
 import { containsRuntimeReference } from "./references.js";
-import {} from "./iterator.js";
-import { coerceToString, createAggregateErrorValue, createErrorValue, errorConstructors } from "../stdlib/value.js";
+import { HostFunction } from "./host.js";
+import {} from "./runner.js";
+import { coerceToString, createAggregateErrorValue, createErrorValue, errorBrandName, errorConstructors, } from "../stdlib/value.js";
 export const normalizeError = (error) => {
     if (error instanceof InterpreterRuntimeError) {
         return {
@@ -41,7 +42,7 @@ export const normalizeError = (error) => {
         }
         else {
             try {
-                message = JSON.stringify(copyOut(value, "json")) ?? String(value);
+                message = JSON.stringify(toData(value, "Thrown value")) ?? String(value);
             }
             catch {
                 message = String(value);
@@ -74,8 +75,8 @@ export const caughtErrorValue = (thrown) => {
     const name = thrown instanceof Error && errorConstructors.has(thrown.name) ? thrown.name : "Error";
     return createErrorValue(name, normalizeError(thrown).message);
 };
-export const constructErrorValue = (name, args) => createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]));
-export const constructAggregateErrorValue = (runner, args, 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).as("TypeError");
@@ -89,3 +90,18 @@ export const constructAggregateErrorValue = (runner, args, node) => Effect.gen(f
         errors.push(step.value);
     }
 });
+/** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
+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);
+        },
+    });
+};

package/dist/interpreter/execute.d.ts

@@ -1,4 +1,4 @@
 import { Effect } from "effect";
-import type { ExecuteOptions, ResolvedExecutionLimits, Result } from "../codemode.js";
-import { ToolRuntime, type Services } from "../tool-runtime.js";
-export declare const executeWithLimits: <const Provided extends Record<string, unknown>>(options: ExecuteOptions<Provided>, limits: ResolvedExecutionLimits, searchIndex: ToolRuntime.DiscoveryPlan["searchIndex"]) => Effect.Effect<Result, never, Services<Provided>>;
+import type { ResolvedExecutionLimits, Result } from "../codemode.js";
+import { ToolRuntime } from "../tool-runtime.js";
+export declare const executeProgram: <R>(code: string, prepared: ToolRuntime.Prepared<R>, limits: ResolvedExecutionLimits, hooks: ToolRuntime.ToolCallHooks<R>) => Effect.Effect<Result, never, R>;

package/dist/interpreter/execute.js

@@ -3,13 +3,14 @@ import { Cause, Effect, Scope } from "effect";
 // #transpile: conditional import — full typescript on node/bun, an identity
 // pass-through on workerd (the compiler is ~11 MiB and can't init there).
 import { transpile } from "#transpile";
-import { copyIn, copyOut, ToolRuntime } from "../tool-runtime.js";
+import { toData } from "../data.js";
+import { ToolRuntime } from "../tool-runtime.js";
 import { normalizeError } from "./errors.js";
-import { InterpreterRuntimeError, isRecord } from "./model.js";
+import { InterpreterRuntimeError } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
-import { Interpreter } from "./runtime.js";
-export const executeWithLimits = (options, limits, searchIndex) => {
-    if (options.code.trim().length === 0) {
+import { Runtime } from "./runtime.js";
+export const executeProgram = (code, prepared, limits, hooks) => {
+    if (code.trim().length === 0) {
         return Effect.succeed({
             ok: false,
             error: { kind: "ParseError", message: "Code cannot be empty." },
@@ -18,20 +19,16 @@ export const executeWithLimits = (options, limits, searchIndex) => {
     }
     // Allocate execution state inside suspension so reused Effects never share it.
     return Effect.suspend(() => {
-        const tools = ToolRuntime.make((options.tools ?? {}), limits.maxToolCalls, searchIndex, {
-            onToolCallStart: options.onToolCallStart,
-            onToolCallEnd: options.onToolCallEnd,
-        });
+        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(options.code);
+            const program = parseProgram(code);
             const promises = new PromiseRuntime(scope);
-            const interpreter = new Interpreter(tools.execute, tools.search, tools.keys, promises, logs);
-            const value = yield* interpreter.run(program);
-            const result = copyOut(copyIn(value, "Execution result"), "nullify");
+            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, logs).run(program);
+            const result = toData(value, "Execution result", "result");
             returned = { value: result, promises };
             const warnings = yield* promises.interrupt();
             return {
@@ -90,17 +87,13 @@ const parseProgram = (code) => {
     const bodyStart = transpiled.outputText.indexOf("{") + 1;
     const bodyEnd = transpiled.outputText.lastIndexOf("}");
     const executableCode = transpiled.outputText.slice(bodyStart, bodyEnd);
-    const parsed = parse(executableCode, {
+    return parse(executableCode, {
         ecmaVersion: "latest",
         sourceType: "script",
         allowReturnOutsideFunction: true,
         allowAwaitOutsideFunction: true,
         locations: true,
     });
-    if (!isRecord(parsed) || parsed.type !== "Program" || !Array.isArray(parsed.body)) {
-        throw new InterpreterRuntimeError("Failed to parse script as a Program node.");
-    }
-    return parsed;
 };
 const utf8ByteLength = (value) => new TextEncoder().encode(value).byteLength;
 // Drop a replacement character produced by truncating inside a UTF-8 sequence.

package/dist/interpreter/globals.d.ts

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

package/dist/interpreter/globals.js

@@ -0,0 +1,59 @@
+import { Effect } from "effect";
+import { arrayGlobal } from "../stdlib/array.js";
+import { mapGlobal, setGlobal } from "../stdlib/collections.js";
+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 { 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, errorConstructors } from "../stdlib/value.js";
+import { ToolReference } from "../tool-runtime.js";
+import { errorGlobal } from "./errors.js";
+import { HostFunction } from "./host.js";
+import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "./model.js";
+import { promiseGlobal } from "./promises.js";
+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) => [
+    ["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")],
+    ...[...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

@@ -1,17 +1,4 @@
 import { Effect } from "effect";
-import { type AstNode, CodeModeFunction, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, IntrinsicReference, JsonMethodReference, PromiseCapabilityFunction, PromiseNamespace, UriFunction } from "./model.js";
-import { CodeModePromise } from "../values.js";
-import { type SyncIteratorRunner } from "./iterator.js";
-export type CallbackRunner<R> = {
-    readonly invokeFunction: (fn: CodeModeFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
-    readonly invokeCallable: (callable: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-    readonly settlePromise: (promise: CodeModePromise) => Effect.Effect<unknown, unknown, never>;
-};
-export type SupportedCallback = CodeModeFunction | CoercionFunction | UriFunction | PromiseCapabilityFunction | GlobalMethodReference | JsonMethodReference | IntrinsicReference | ErrorConstructorReference | GlobalNamespace | PromiseNamespace;
-export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;
-export declare const invokeIntrinsic: <R>(runner: CallbackRunner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export declare const invokeGlobalMethod: (ref: GlobalMethodReference, args: Array<unknown>, node: AstNode) => unknown;
-export declare const arrayStatics: Set<string>;
-export declare const invokeArrayFrom: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export declare const invokeGroupBy: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, namespace: "Map" | "Object", args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export declare const applyCollectionCallback: <R>(runner: CallbackRunner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);
+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>;