@opencode/codemode 0.0.0-beta-19507 → 0.0.0-dev-19274

package/dist/tool-runtime.js

@@ -1,10 +1,10 @@
 import { Cause, Effect, Exit, Formatter, Schema } from "effect";
-import { fromData, toData, ToolRuntimeError } from "./data.js";
 import { toolError } from "./tool-error.js";
 import { decodeInput as decodeToolInput, decodeOutput as decodeToolOutput, identifierSegment, inputProperties, inputTypeScript, isEmptyInput, outputTypeScript, } from "./tool-schema.js";
 import { isNamespace } from "./namespace.js";
 import { isTool } from "./tool.js";
-export const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+import { CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "./values.js";
+const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
 const defaultSearchLimit = 10;
 const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
 const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
@@ -35,6 +35,143 @@ export class ToolReference {
         this.path = path;
     }
 }
+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);
+// Checkpoint mode preserves CodeMode values; boundary mode JSON-normalizes them.
+export const copyIn = (value, label, preserveCodeModeValues = false) => copyBounded(value, label, 0, new Set(), preserveCodeModeValues);
+const copyBounded = (value, label, depth, seen, preserveCodeModeValues) => {
+    if (depth > MAX_VALUE_DEPTH) {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`);
+    }
+    if (value === null ||
+        value === undefined ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        typeof value === "number") {
+        return value;
+    }
+    if (typeof value !== "object") {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
+    }
+    if (value instanceof CodeModePromise) {
+        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 (preserveCodeModeValues) {
+        if (value instanceof CodeModeDate ||
+            value instanceof CodeModeRegExp ||
+            value instanceof CodeModeMap ||
+            value instanceof CodeModeSet ||
+            value instanceof CodeModeURL ||
+            value instanceof CodeModeURLSearchParams) {
+            return value;
+        }
+        if (value instanceof Date)
+            return new CodeModeDate(value.getTime());
+        if (value instanceof RegExp)
+            return new CodeModeRegExp(value.source, value.flags);
+        if (value instanceof Map) {
+            const wrapped = new CodeModeMap();
+            for (const [key, item] of value.entries()) {
+                wrapped.map.set(copyBounded(key, label, depth + 1, seen, true), copyBounded(item, label, depth + 1, seen, true));
+            }
+            return wrapped;
+        }
+        if (value instanceof Set) {
+            const wrapped = new CodeModeSet();
+            for (const item of value.values())
+                wrapped.set.add(copyBounded(item, label, depth + 1, seen, true));
+            return wrapped;
+        }
+        if (value instanceof URL)
+            return new CodeModeURL(new URL(value.href));
+        if (value instanceof URLSearchParams)
+            return new CodeModeURLSearchParams(new URLSearchParams(value));
+    }
+    if (value instanceof CodeModeDate) {
+        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 CodeModeURL)
+        return value.url.href;
+    if (value instanceof URL)
+        return value.href;
+    if (value instanceof CodeModeRegExp ||
+        value instanceof CodeModeMap ||
+        value instanceof CodeModeSet ||
+        value instanceof CodeModeURLSearchParams ||
+        value instanceof RegExp ||
+        value instanceof Map ||
+        value instanceof Set ||
+        value instanceof URLSearchParams) {
+        return Object.create(null);
+    }
+    if (seen.has(value)) {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} contains a circular value.`);
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const copied = value.map((item) => copyBounded(item, label, depth + 1, seen, preserveCodeModeValues));
+        if (preserveCodeModeValues) {
+            // Checkpoint copies retain array metadata that boundary copies omit.
+            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, copyBounded(item, label, depth + 1, seen, true));
+            }
+        }
+        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 = Object.create(null);
+    for (const [key, item] of Object.entries(value)) {
+        if (isBlockedMember(key)) {
+            throw new ToolRuntimeError("InvalidDataValue", `${label} contains blocked property '${key}'.`);
+        }
+        copied[key] = copyBounded(item, label, depth + 1, seen, preserveCodeModeValues);
+    }
+    seen.delete(value);
+    return copied;
+};
+export const copyOut = (value, mode) => {
+    if (value === undefined && mode === "nullify")
+        return null;
+    if (typeof value === "number" && !Number.isFinite(value)) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        // Array.from densifies holes so sparse arrays normalize at the boundary like JSON does.
+        return Array.from(value, (item) => {
+            const copied = copyOut(item, mode);
+            return copied === undefined && mode === "json" ? null : copied;
+        });
+    }
+    if (value !== null && typeof value === "object" && !(value instanceof ToolReference)) {
+        return Object.fromEntries(Object.entries(value)
+            .map(([key, item]) => [key, copyOut(item, mode)])
+            .filter(([, item]) => !(item === undefined && mode === "json")));
+    }
+    return value;
+};
 const toolTrie = (tools) => {
     const root = { children: new Map() };
     const insert = (node, group) => {
@@ -75,6 +212,8 @@ const describeTool = (visible) => ({
         ? `${toolExpression(visible.path)}(): Promise<${outputTypeScript(visible.tool, true)}>`
         : `${toolExpression(visible.path)}(input: ${inputTypeScript(visible.tool, true)}): Promise<${outputTypeScript(visible.tool, true)}>`,
 });
+// Discovery bytes are durable instructions, so order only after canonical-path collisions settle.
+const visibleTools = (tools) => flattenTools(toolTrie(tools)).sort((left, right) => compareText(left.path, right.path));
 const tokenize = (query) => query
     .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
     .toLowerCase()
@@ -151,12 +290,10 @@ const toSearchEntry = (visible) => ({
         .join("\n")
         .toLowerCase(),
 });
+export const searchIndex = (tools) => visibleTools(tools).map(toSearchEntry);
 export const prepare = (tools) => {
-    const root = toolTrie(tools);
-    // Discovery bytes are durable instructions, so order only after canonical-path collisions settle.
-    const visible = flattenTools(root).sort((left, right) => compareText(left.path, right.path));
+    const visible = visibleTools(tools);
     return {
-        root,
         catalog: visible.map(describeTool),
         searchIndex: visible.map(toSearchEntry),
     };
@@ -183,11 +320,10 @@ const resolve = (root, path) => {
     }
     return node.tool;
 };
-/** Per-execution call state over tools prepared once for the runtime. */
-export const make = (prepared, maxToolCalls, hooks) => {
+export const make = (tools, maxToolCalls, searchIndex, hooks) => {
     const calls = [];
-    const root = prepared.root;
-    const searchTool = makeSearchTool(prepared.searchIndex);
+    const root = toolTrie(tools);
+    const searchTool = makeSearchTool(searchIndex);
     const observeEnd = (effect, call) => {
         const onEnd = hooks?.onToolCallEnd;
         if (onEnd === undefined)
@@ -234,18 +370,19 @@ export const make = (prepared, maxToolCalls, hooks) => {
                     .join("\n")));
             }));
             return yield* Effect.try({
-                try: () => fromData(decodeToolOutput(tool, raw), `Result from tool '${name}'`),
+                try: () => copyIn(decodeToolOutput(tool, raw), `Result from tool '${name}'`),
                 catch: (cause) => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}': ${cause}`),
             });
         }), call);
     });
     return {
+        root: new ToolReference([]),
         calls,
         keys: (path) => namespaceKeys(root, path),
-        search: (args) => Effect.suspend(() => executeTool("search", searchTool, args.map((arg) => toData(arg, "Arguments for tool 'search'")))),
+        search: (args) => Effect.suspend(() => executeTool("search", searchTool, args.map((arg) => copyOut(copyIn(arg, "Arguments for tool 'search'"), "json")))),
         execute: (path, args) => Effect.gen(function* () {
             const name = canonicalSegments(path).join(".");
-            const externalArgs = args.map((arg) => toData(arg, `Arguments for tool '${name}'`));
+            const externalArgs = args.map((arg) => copyOut(copyIn(arg, `Arguments for tool '${name}'`), "json"));
             const tool = resolve(root, path);
             return yield* executeTool(name, tool, externalArgs);
         }),

package/dist/values.d.ts

@@ -1,37 +1,31 @@
-export * as Values from "./values.js";
 import type { Fiber } from "effect";
-/**
- * Runtime values the interpreter recognizes by class. Each wraps the host value it stands for,
- * so hosts construct these to hand a value to a program and receive them back unchanged.
- */
-export declare class Promise {
+export declare class CodeModePromise {
     readonly fiber: Fiber.Fiber<unknown, unknown>;
     constructor(fiber: Fiber.Fiber<unknown, unknown>);
 }
-export declare class Date {
+export declare class CodeModeDate {
     time: number;
     constructor(time: number);
 }
-export declare class RegExp {
-    readonly regex: globalThis.RegExp;
+export declare class CodeModeRegExp {
+    readonly regex: RegExp;
     constructor(pattern: string, flags: string);
     get lastIndex(): unknown;
     set lastIndex(value: unknown);
 }
-export declare class Map {
-    readonly map: globalThis.Map<unknown, unknown>;
+export declare class CodeModeMap {
+    readonly map: Map<unknown, unknown>;
 }
-export declare class Set {
-    readonly set: globalThis.Set<unknown>;
+export declare class CodeModeSet {
+    readonly set: Set<unknown>;
 }
-export declare class URLSearchParams {
-    readonly params: globalThis.URLSearchParams;
-    constructor(params: globalThis.URLSearchParams);
+export declare class CodeModeURLSearchParams {
+    readonly params: URLSearchParams;
+    constructor(params: URLSearchParams);
 }
-export declare class URL {
-    readonly url: globalThis.URL;
-    readonly searchParams: URLSearchParams;
-    constructor(url: globalThis.URL);
+export declare class CodeModeURL {
+    readonly url: URL;
+    readonly searchParams: CodeModeURLSearchParams;
+    constructor(url: URL);
 }
-/** Data-like runtime values; excludes Promise, which never crosses a boundary. */
-export declare const isValue: (value: unknown) => value is Date | RegExp | Map | Set | URL | URLSearchParams;
+export declare const isCodeModeValue: (value: unknown) => value is CodeModeDate | CodeModeRegExp | CodeModeMap | CodeModeSet | CodeModeURL | CodeModeURLSearchParams;

package/dist/values.js

@@ -1,24 +1,19 @@
-export * as Values from "./values.js";
-/**
- * Runtime values the interpreter recognizes by class. Each wraps the host value it stands for,
- * so hosts construct these to hand a value to a program and receive them back unchanged.
- */
-export class Promise {
+export class CodeModePromise {
     fiber;
     constructor(fiber) {
         this.fiber = fiber;
     }
 }
-export class Date {
+export class CodeModeDate {
     time;
     constructor(time) {
         this.time = time;
     }
 }
-export class RegExp {
+export class CodeModeRegExp {
     regex;
     constructor(pattern, flags) {
-        this.regex = new globalThis.RegExp(pattern, flags);
+        this.regex = new RegExp(pattern, flags);
     }
     get lastIndex() {
         return Reflect.get(this.regex, "lastIndex");
@@ -27,30 +22,29 @@ export class RegExp {
         Reflect.set(this.regex, "lastIndex", value);
     }
 }
-export class Map {
-    map = new globalThis.Map();
+export class CodeModeMap {
+    map = new Map();
 }
-export class Set {
-    set = new globalThis.Set();
+export class CodeModeSet {
+    set = new Set();
 }
-export class URLSearchParams {
+export class CodeModeURLSearchParams {
     params;
     constructor(params) {
         this.params = params;
     }
 }
-export class URL {
+export class CodeModeURL {
     url;
     searchParams;
     constructor(url) {
         this.url = url;
-        this.searchParams = new URLSearchParams(url.searchParams);
+        this.searchParams = new CodeModeURLSearchParams(url.searchParams);
     }
 }
-/** Data-like runtime values; excludes Promise, which never crosses a boundary. */
-export const isValue = (value) => value instanceof Date ||
-    value instanceof RegExp ||
-    value instanceof Map ||
-    value instanceof Set ||
-    value instanceof URL ||
-    value instanceof URLSearchParams;
+export const isCodeModeValue = (value) => value instanceof CodeModeDate ||
+    value instanceof CodeModeRegExp ||
+    value instanceof CodeModeMap ||
+    value instanceof CodeModeSet ||
+    value instanceof CodeModeURL ||
+    value instanceof CodeModeURLSearchParams;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-beta-19507",
+  "version": "0.0.0-dev-19274",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",

package/dist/data.d.ts

@@ -1,25 +0,0 @@
-export * as Data from "./data.js";
-import type { DiagnosticKind } from "./codemode.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 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: (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: (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

@@ -1,153 +0,0 @@
-export * as Data from "./data.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;
-    suggestions;
-    constructor(kind, message, suggestions = []) {
-        super(message);
-        this.kind = kind;
-        this.suggestions = suggestions;
-        this.name = "ToolRuntimeError";
-    }
-}
-/**
- * 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 = (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 = (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 (value instanceof ProgramFunction && mode !== "program") {
-        throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
-    }
-    const plain = mode === "program" || mode === "data";
-    if (mode === "program") {
-        if (value instanceof ProgramObject || 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));
-    }
-    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 ? 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) => copy(item, label, mode, depth + 1, seen) ?? null);
-        seen.delete(value);
-        return copied;
-    }
-    if (value instanceof ProgramObject) {
-        const copied = {};
-        for (const [key, item] of ownEntries(value)) {
-            const next = copy(item, label, mode, depth + 1, seen);
-            if (next === undefined && mode === "json")
-                continue;
-            define(copied, key, next);
-        }
-        seen.delete(value);
-        return copied;
-    }
-    if (Array.isArray(value)) {
-        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)
-                    set(copied, key, copy(item, label, mode, depth + 1, seen));
-            }
-            seen.delete(value);
-            return copied;
-        }
-        const copied = Array.from(value, (item) => copy(item, label, mode, depth + 1, seen) ?? null);
-        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.`);
-    }
-    if (plain) {
-        const copied = new ProgramObject();
-        for (const [key, item] of Object.entries(value))
-            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 next = copy(item, label, mode, depth + 1, seen);
-        if (next === undefined && mode === "json")
-            continue;
-        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 define = (target, key, value) => {
-    Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
-};

package/dist/interpreter/globals.d.ts

@@ -1,13 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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 { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.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")],
-    ["atob", atobGlobal],
-    ["btoa", btoaGlobal],
-    ["crypto", cryptoGlobal],
-    ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)]),
-];

package/dist/interpreter/host.d.ts

@@ -1,41 +0,0 @@
-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 {};