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

package/dist/stdlib/regexp.js

@@ -1,9 +1,9 @@
-import { sync, syncCall } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { ProgramArray, record, set } from "../interpreter/objects.js";
-import { Values } from "../values.js";
+import { isBlockedMember } from "../tool-runtime.js";
+import { CodeModeRegExp } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 export const regexpMethods = new Set(["test", "exec", "toString"]);
+export const regexpStatics = new Set(["escape"]);
 export const regexpProperties = new Set([
     "source",
     "flags",
@@ -17,13 +17,13 @@ export const regexpProperties = new Set([
     "unicodeSets",
     "dotAll",
 ]);
-const regexFailureReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "");
-const escapeRegexHint = 'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.';
+export const regexFailureReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "");
+export const escapeRegexHint = 'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.';
 export const toHostRegex = (arg, method, node, extraFlags = "") => {
     // Native parity: an undefined pattern behaves as an empty pattern.
     if (arg === undefined)
         return new RegExp("", extraFlags);
-    if (arg instanceof Values.RegExp)
+    if (arg instanceof CodeModeRegExp)
         return arg.regex;
     if (typeof arg === "string") {
         try {
@@ -36,48 +36,29 @@ export const toHostRegex = (arg, method, node, extraFlags = "") => {
     throw new InterpreterRuntimeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`, node);
 };
 export const matchToValue = (match) => {
-    const result = new ProgramArray(Array.from(match, (group) => group));
+    const result = Array.from(match, (group) => group);
     if (match.index !== undefined)
-        set(result, "index", match.index);
-    if (match.input !== undefined)
-        set(result, "input", match.input);
-    if (match.groups)
-        set(result, "groups", record(match.groups));
+        result.index = match.index;
+    if (match.groups) {
+        const groups = Object.create(null);
+        for (const [key, group] of Object.entries(match.groups)) {
+            if (!isBlockedMember(key))
+                groups[key] = group;
+        }
+        result.groups = groups;
+    }
     if (match.indices)
-        set(result, "indices", indicesToValue(match.indices));
+        result.indices = indicesToValue(match.indices);
     return result;
 };
-export const constructRegExp = (args, node) => {
-    const first = args[0];
-    const pattern = first instanceof Values.RegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
-    const flagsArg = args[1];
-    if (flagsArg !== undefined && typeof flagsArg !== "string") {
-        throw new InterpreterRuntimeError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node).as("SyntaxError");
-    }
-    const flags = flagsArg ?? (first instanceof Values.RegExp ? first.regex.flags : "");
-    try {
-        return new Values.RegExp(pattern, flags);
-    }
-    catch (error) {
-        const reason = regexFailureReason(error);
-        throw new InterpreterRuntimeError(/flag/i.test(reason)
-            ? `new RegExp(...) received invalid flags ${JSON.stringify(flags)} (${reason}). Valid flags are d, g, i, m, s, u, v, and y.`
-            : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`, node).as("SyntaxError");
+export const invokeRegExpStatic = (name, args, node) => {
+    if (name !== "escape")
+        throw new InterpreterRuntimeError(`RegExp.${name} is not available.`, node);
+    if (typeof args[0] !== "string") {
+        throw new InterpreterRuntimeError("RegExp.escape expects a string.", node).as("TypeError");
     }
+    return RegExp.escape(args[0]);
 };
-// RegExp constructs identically with or without new, like JS.
-export const regexpGlobal = sync("RegExp", constructRegExp, {
-    construct: syncCall(constructRegExp),
-    instanceOf: (value) => value instanceof Values.RegExp,
-    members: {
-        escape: sync("RegExp.escape", (args, node) => {
-            if (typeof args[0] !== "string") {
-                throw new InterpreterRuntimeError("RegExp.escape expects a string.", node).as("TypeError");
-            }
-            return RegExp.escape(args[0]);
-        }),
-    },
-});
 export const invokeRegExpMethod = (value, name, args, node) => {
     switch (name) {
         case "test":
@@ -110,11 +91,16 @@ const toLength = (value) => {
     return Math.min(Math.floor(number), Number.MAX_SAFE_INTEGER);
 };
 const indicesToValue = (indices) => {
-    const range = (pair) => (pair === undefined ? undefined : new ProgramArray([...pair]));
-    const result = new ProgramArray(Array.from(indices, range));
-    const groups = indices.groups;
-    set(result, "groups", groups === undefined
-        ? undefined
-        : record(Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
+    const result = Array.from(indices, (range) => (range === undefined ? undefined : [...range]));
+    if (indices.groups) {
+        const groups = Object.create(null);
+        for (const [key, range] of Object.entries(indices.groups)) {
+            if (!isBlockedMember(key))
+                groups[key] = range === undefined ? undefined : [...range];
+        }
+        result.groups = groups;
+        return result;
+    }
+    result.groups = undefined;
     return result;
 };

package/dist/stdlib/string.d.ts

@@ -1,2 +1,4 @@
 export declare const stringMethods: Set<string>;
-export declare const stringGlobal: import("../interpreter/host.js").HostFunction<never>;
+export declare const stringStatics: Set<string>;
+export declare const invokeStringStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+import { type AstNode } from "../interpreter/model.js";

package/dist/stdlib/string.js

@@ -1,18 +1,12 @@
-import { sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { coercion } from "./value.js";
 export const stringMethods = new Set([
     "toLowerCase",
     "toUpperCase",
     "trim",
     "trimStart",
     "trimEnd",
-    "trimLeft",
-    "trimRight",
     "split",
     "slice",
     "substring",
-    "substr",
     "includes",
     "startsWith",
     "endsWith",
@@ -34,18 +28,21 @@ export const stringMethods = new Set([
     "search",
     "localeCompare",
     "normalize",
-    "isWellFormed",
-    "toWellFormed",
 ]);
-const codeUnits = (name, op) => sync(`String.${name}`, (args, node) => op(...args.map((arg) => {
-    if (typeof arg !== "number")
-        throw new InterpreterRuntimeError(`String.${name} expects number arguments.`, node);
-    return arg;
-})));
-export const stringGlobal = coercion("String", {
-    instanceOf: () => false,
-    members: {
-        fromCharCode: codeUnits("fromCharCode", String.fromCharCode),
-        fromCodePoint: codeUnits("fromCodePoint", String.fromCodePoint),
-    },
-});
+export const stringStatics = new Set(["fromCharCode", "fromCodePoint"]);
+export const invokeStringStatic = (name, args, node) => {
+    const codes = args.map((arg) => {
+        if (typeof arg !== "number")
+            throw new InterpreterRuntimeError(`String.${name} expects number arguments.`, node);
+        return arg;
+    });
+    switch (name) {
+        case "fromCharCode":
+            return String.fromCharCode(...codes);
+        case "fromCodePoint":
+            return String.fromCodePoint(...codes);
+        default:
+            throw new InterpreterRuntimeError(`String.${name} is not available.`, node);
+    }
+};
+import { InterpreterRuntimeError } from "../interpreter/model.js";

package/dist/stdlib/url.d.ts

@@ -1,16 +1,12 @@
-import { HostFunction } from "../interpreter/host.js";
-import { type AstNode } from "../interpreter/model.js";
-import { type Runner } from "../interpreter/runner.js";
-import { Values } from "../values.js";
 export declare const urlProperties: Set<string>;
 export declare const urlWritableProperties: Set<string>;
 export declare const urlMethods: Set<string>;
+export declare const urlStatics: Set<string>;
 export declare const urlSearchParamsMethods: Set<string>;
 export declare const uriArgument: (value: unknown, label: string) => string;
-type UriFunction = "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
-export declare const uriGlobal: (name: UriFunction) => HostFunction<never>;
+export declare const invokeUriFunction: (ref: UriFunction, args: Array<unknown>, node: AstNode) => string;
 export declare const urlArgument: (value: unknown, label: string) => string;
-export declare const urlGlobal: HostFunction<never>;
-export declare const urlSearchParamsGlobal: <R>(runner: Runner<R>) => HostFunction<R>;
-export declare const invokeURLMethod: (value: Values.URL, name: string, node: AstNode) => string;
-export {};
+export declare const invokeURLStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const invokeURLMethod: (value: CodeModeURL, name: string, node: AstNode) => string;
+import { type AstNode, UriFunction } from "../interpreter/model.js";
+import { CodeModeURL } from "../values.js";

package/dist/stdlib/url.js

@@ -1,12 +1,3 @@
-import { Effect } from "effect";
-import { toProgram } from "../data.js";
-import { HostFunction, requiresNew, sync, syncCall } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { ownEntries, ProgramObject } from "../interpreter/objects.js";
-import { isRuntimeReference } from "../interpreter/references.js";
-import { preserveConsumerError } from "../interpreter/runner.js";
-import { Values } from "../values.js";
-import { coerceToString } from "./value.js";
 export const urlProperties = new Set([
     "href",
     "origin",
@@ -33,6 +24,7 @@ export const urlWritableProperties = new Set([
     "hash",
 ]);
 export const urlMethods = new Set(["toString", "toJSON"]);
+export const urlStatics = new Set(["canParse", "parse"]);
 export const urlSearchParamsMethods = new Set([
     "append",
     "delete",
@@ -47,115 +39,46 @@ export const urlSearchParamsMethods = new Set([
     "entries",
     "toString",
 ]);
-export const uriArgument = (value, label) => coerceToString(toProgram(value, label));
-const uriFunctions = {
-    encodeURI,
-    encodeURIComponent,
-    decodeURI,
-    decodeURIComponent,
-};
-export const uriGlobal = (name) => sync(name, (args, node) => {
-    const value = uriArgument(args[0], `${name} input`);
+export const uriArgument = (value, label) => coerceToString(boundedData(value, label));
+export const invokeUriFunction = (ref, args, node) => {
+    const value = uriArgument(args[0], `${ref.name} input`);
     try {
-        return uriFunctions[name](value);
+        switch (ref.name) {
+            case "encodeURI":
+                return encodeURI(value);
+            case "encodeURIComponent":
+                return encodeURIComponent(value);
+            case "decodeURI":
+                return decodeURI(value);
+            case "decodeURIComponent":
+                return decodeURIComponent(value);
+        }
     }
     catch (error) {
-        throw new InterpreterRuntimeError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
+        throw new InterpreterRuntimeError(`${ref.name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
     }
-});
-export const urlArgument = (value, label) => value instanceof Values.URL ? value.url.href : uriArgument(value, label);
-const urlStatic = (name) => sync(`URL.${name}`, (args, node) => {
-    if (args.length === 0) {
+};
+export const urlArgument = (value, label) => value instanceof CodeModeURL ? value.url.href : uriArgument(value, label);
+export const invokeURLStatic = (name, args, node) => {
+    if (!urlStatics.has(name))
+        throw new InterpreterRuntimeError(`URL.${name} is not available.`, node);
+    if (args.length === 0)
         throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node).as("TypeError");
-    }
     const input = urlArgument(args[0], `URL.${name} input`);
     const base = args[1] === undefined ? undefined : urlArgument(args[1], `URL.${name} base`);
     try {
         const url = new URL(input, base);
-        return name === "canParse" ? true : new Values.URL(url);
+        return name === "canParse" ? true : new CodeModeURL(url);
     }
     catch {
         return name === "canParse" ? false : null;
     }
-});
-const constructURL = (args, node) => {
-    if (args.length === 0) {
-        throw new InterpreterRuntimeError("new URL(...) requires a URL string and an optional base URL.", node).as("TypeError");
-    }
-    const input = urlArgument(args[0], "new URL input");
-    const base = args[1] === undefined ? undefined : urlArgument(args[1], "new URL base");
-    try {
-        return new Values.URL(new URL(input, base));
-    }
-    catch {
-        throw new InterpreterRuntimeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`, node).as("TypeError");
-    }
-};
-export const urlGlobal = new HostFunction({
-    name: "URL",
-    call: requiresNew("URL"),
-    construct: syncCall(constructURL),
-    instanceOf: (value) => value instanceof Values.URL,
-    members: { canParse: urlStatic("canParse"), parse: urlStatic("parse") },
-});
-const readURLSearchParamsPair = (runner, value, node) => Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(value, node);
-    if (cursor === undefined) {
-        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
-    }
-    const items = [];
-    while (true) {
-        const step = yield* cursor.next;
-        if (step.done)
-            return items;
-        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => uriArgument(step.value, "URLSearchParams pair value"))));
-    }
-});
-const constructURLSearchParams = (runner, init, node) => {
-    if (init === undefined)
-        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams()));
-    if (init instanceof Values.URLSearchParams) {
-        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init.params)));
-    }
-    if (typeof init === "string")
-        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init)));
-    if (init === null || typeof init === "number" || typeof init === "boolean") {
-        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(coerceToString(init))));
-    }
-    return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(init, node);
-        if (cursor !== undefined) {
-            const entries = [];
-            while (true) {
-                const step = yield* cursor.next;
-                if (step.done) {
-                    if (entries.some((entry) => entry.length !== 2)) {
-                        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
-                    }
-                    return new Values.URLSearchParams(new URLSearchParams(entries.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
-                }
-                entries.push(yield* preserveConsumerError(cursor, readURLSearchParamsPair(runner, step.value, node)));
-            }
-        }
-        if (isRuntimeReference(init)) {
-            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node).as("TypeError");
-        }
-        if (Values.isValue(init))
-            return new Values.URLSearchParams(new URLSearchParams());
-        if (!(init instanceof ProgramObject)) {
-            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node).as("TypeError");
-        }
-        return new Values.URLSearchParams(new URLSearchParams(Object.fromEntries(ownEntries(init).map(([key, value]) => [key, coerceToString(value)]))));
-    });
 };
-export const urlSearchParamsGlobal = (runner) => new HostFunction({
-    name: "URLSearchParams",
-    call: requiresNew("URLSearchParams"),
-    construct: (args, node) => constructURLSearchParams(runner, args[0], node),
-    instanceOf: (value) => value instanceof Values.URLSearchParams,
-});
 export const invokeURLMethod = (value, name, node) => {
     if (name === "toString" || name === "toJSON")
         return value.url.href;
     throw new InterpreterRuntimeError(`URL method '${name}' is not available.`, node);
 };
+import { InterpreterRuntimeError, UriFunction } from "../interpreter/model.js";
+import { CodeModeURL } from "../values.js";
+import { boundedData, coerceToString } from "./value.js";

package/dist/stdlib/value.d.ts

@@ -1,13 +1,12 @@
-import { type HostFunction, type SyncOptions } from "../interpreter/host.js";
-import { ProgramError } from "../interpreter/objects.js";
 export declare const errorConstructors: Set<string>;
+export declare const valueConstructors: Set<string>;
 export declare const compoundOperators: Set<string>;
-export declare const createErrorValue: (name: string, message: string) => ProgramError;
-export declare const createAggregateErrorValue: (errors: Array<unknown>, message: string) => ProgramError;
+export declare const createErrorValue: (name: string, message: string) => SafeObject;
+export declare const createAggregateErrorValue: (errors: Array<unknown>, message: string) => SafeObject;
 export declare const errorBrandName: (value: unknown) => string | undefined;
+export declare const boundedData: (value: unknown, label: string) => unknown;
 export declare const coerceToString: (value: unknown) => string;
 export declare const coerceToNumber: (value: unknown) => number;
-type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
-/** A global coercion function such as `Number` or `parseInt`. */
-export declare const coercion: (name: Coercion, options?: SyncOptions) => HostFunction;
-export {};
+export declare const invokeCoercion: (ref: CoercionFunction, args: Array<unknown>, node: AstNode) => unknown;
+import { type AstNode, CoercionFunction } from "../interpreter/model.js";
+import { type SafeObject } from "../tool-runtime.js";

package/dist/stdlib/value.js

@@ -1,8 +1,3 @@
-import { sync } from "../interpreter/host.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { toProgram } from "../data.js";
-import { get, ProgramArray, ProgramError, set } from "../interpreter/objects.js";
-import { Values } from "../values.js";
 export const errorConstructors = new Set([
     "Error",
     "TypeError",
@@ -13,108 +8,113 @@ export const errorConstructors = new Set([
     "URIError",
     "AggregateError",
 ]);
+export const valueConstructors = new Set(["Date", "RegExp", "Map", "Set", "URL", "URLSearchParams"]);
 export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="]);
+const ErrorBrand = Symbol("codemode.error");
 export const createErrorValue = (name, message) => {
-    const value = new ProgramError(name);
-    set(value, "name", name);
-    set(value, "message", message);
+    const value = Object.assign(Object.create(null), { name, message });
+    Object.defineProperty(value, ErrorBrand, { value: name });
     return value;
 };
-export const createAggregateErrorValue = (errors, message) => {
-    const value = createErrorValue("AggregateError", message);
-    set(value, "errors", new ProgramArray(errors));
-    return value;
-};
-export const errorBrandName = (value) => value instanceof ProgramError ? value.errorName : undefined;
+export const createAggregateErrorValue = (errors, message) => Object.assign(createErrorValue("AggregateError", message), { errors });
+export const errorBrandName = (value) => value !== null && typeof value === "object"
+    ? value[ErrorBrand]
+    : undefined;
+export const boundedData = (value, label) => copyIn(value, label, true);
 export const coerceToString = (value) => {
     if (value === null)
         return "null";
     if (value === undefined)
         return "undefined";
-    if (value instanceof Values.Date)
+    if (value instanceof CodeModeDate)
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date";
-    if (value instanceof Values.RegExp)
+    if (value instanceof CodeModeRegExp)
         return `/${value.regex.source}/${value.regex.flags}`;
-    if (value instanceof Values.Map)
+    if (value instanceof CodeModeMap)
         return "[object Map]";
-    if (value instanceof Values.Set)
+    if (value instanceof CodeModeSet)
         return "[object Set]";
-    if (value instanceof Values.URL)
+    if (value instanceof CodeModeURL)
         return value.url.href;
-    if (value instanceof Values.URLSearchParams)
+    if (value instanceof CodeModeURLSearchParams)
         return value.params.toString();
-    if (value instanceof ProgramError) {
+    if (errorBrandName(value) !== undefined) {
         // Match Error.prototype.toString: "name: message", or just one when the other is empty.
-        const name = get(value, "name");
-        const message = get(value, "message");
-        const shownName = typeof name === "string" ? name : "Error";
-        const shownMessage = typeof message === "string" ? message : "";
-        if (shownMessage === "")
-            return shownName;
-        if (shownName === "")
-            return shownMessage;
-        return `${shownName}: ${shownMessage}`;
+        const error = value;
+        const name = typeof error.name === "string" ? error.name : "Error";
+        const message = typeof error.message === "string" ? error.message : "";
+        if (message === "")
+            return name;
+        if (name === "")
+            return message;
+        return `${name}: ${message}`;
     }
-    if (value instanceof ProgramArray) {
-        return value.items.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",");
+    if (typeof value === "object") {
+        return Array.isArray(value)
+            ? value.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",")
+            : "[object Object]";
     }
-    if (typeof value === "object")
-        return "[object Object]";
     return String(value);
 };
 export const coerceToNumber = (value) => {
-    if (value instanceof Values.Date)
+    if (value instanceof CodeModeDate)
         return value.time;
-    if (Values.isValue(value))
+    if (isCodeModeValue(value))
         return Number.NaN;
-    if (value instanceof ProgramArray)
+    // Arrays coerce through our own string coercion: host Number(array) joins with host
+    // ToPrimitive, which throws on the null-prototype objects the interpreter produces.
+    if (Array.isArray(value))
         return Number(coerceToString(value));
     return value !== null && typeof value === "object" ? Number.NaN : Number(value);
 };
-const coerce = (name, args, node) => {
+export const invokeCoercion = (ref, args, node) => {
     // Native: Number() is 0 and String() is "", unlike their undefined-argument forms; the
     // other coercers match native through the undefined-argument path below.
     if (args.length === 0) {
-        if (name === "Number")
+        if (ref.name === "Number")
             return 0;
-        if (name === "String")
+        if (ref.name === "String")
             return "";
     }
     const raw = args[0];
-    if (Values.isValue(raw)) {
-        if (name === "Boolean")
+    // Error values are plain SafeObjects; the boundedData path below would strip their brand.
+    if (ref.name === "String" && errorBrandName(raw) !== undefined)
+        return coerceToString(raw);
+    if (isCodeModeValue(raw)) {
+        if (ref.name === "Boolean")
             return true;
-        if (name === "Number")
+        if (ref.name === "Number")
             return coerceToNumber(raw);
-        if (name === "String")
+        if (ref.name === "String")
             return coerceToString(raw);
-        if (name === "isFinite")
+        if (ref.name === "isFinite")
             return Number.isFinite(coerceToNumber(raw));
-        if (name === "isNaN")
+        if (ref.name === "isNaN")
             return Number.isNaN(coerceToNumber(raw));
-        if (name === "parseInt")
+        if (ref.name === "parseInt")
             return parseInt(coerceToString(raw));
         return parseFloat(coerceToString(raw));
     }
-    const value = toProgram(raw, `${name} input`);
-    if (name === "Number")
+    const value = boundedData(raw, `${ref.name} input`);
+    if (ref.name === "Number")
         return coerceToNumber(value);
-    if (name === "Boolean")
+    if (ref.name === "Boolean")
         return Boolean(value);
-    if (name === "isFinite")
+    if (ref.name === "isFinite")
         return Number.isFinite(coerceToNumber(value));
-    if (name === "isNaN")
+    if (ref.name === "isNaN")
         return Number.isNaN(coerceToNumber(value));
-    if (name === "parseInt") {
+    if (ref.name === "parseInt") {
         const radix = args[1];
         if (radix !== undefined && typeof radix !== "number") {
             throw new InterpreterRuntimeError("parseInt expects a numeric radix.", node);
         }
         return parseInt(coerceToString(value), radix);
     }
-    if (name === "parseFloat")
+    if (ref.name === "parseFloat")
         return parseFloat(coerceToString(value));
     return coerceToString(value);
 };
-/** A global coercion function such as `Number` or `parseInt`. */
-export const coercion = (name, options = {}) => sync(name, (args, node) => toProgram(coerce(name, args, node), `${name} result`), options);
+import { CoercionFunction, InterpreterRuntimeError } from "../interpreter/model.js";
+import { copyIn } from "../tool-runtime.js";
+import { isCodeModeValue, CodeModeDate, CodeModeMap, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";

package/dist/tool-runtime.d.ts

@@ -1,8 +1,5 @@
 import { Effect } from "effect";
-import { type Namespace } from "./namespace.js";
-import { type Tool } from "./tool.js";
 import type { Tools } from "./tools.js";
-export declare const compareText: (left: string, right: string) => 1 | -1 | 0;
 export type Services<T> = ServicesOf<T, []>;
 type ServicesOf<T, Depth extends ReadonlyArray<unknown>> = Depth["length"] extends 8 ? never : T extends {
     readonly _tag: "CodeModeTool";
@@ -25,9 +22,7 @@ export type ToolCallEnded = {
     readonly message?: string;
 };
 export type ToolCallHooks<R = never> = {
-    /** Observes decoded tool input immediately before tool execution. */
     readonly onToolCallStart?: ((call: ToolCallStarted) => Effect.Effect<void, never, R>) | undefined;
-    /** Observes each admitted tool call as it succeeds, fails, or is interrupted. */
     readonly onToolCallEnd?: ((call: ToolCallEnded) => Effect.Effect<void, never, R>) | undefined;
 };
 export type ToolDescription = {
@@ -35,19 +30,22 @@ export type ToolDescription = {
     readonly description: string;
     readonly signature: string;
 };
+export type SafeObject = Record<string, unknown>;
 export declare const toolExpression: (path: string) => string;
 export declare class ToolReference {
     readonly path: ReadonlyArray<string>;
     constructor(path: ReadonlyArray<string>);
 }
-type ToolNode<R> = {
-    tool?: Tool<R>;
-    namespace?: Namespace<R>;
-    readonly children: Map<string, ToolNode<R>>;
-};
-/** Tools indexed once per runtime: the lookup trie plus the model-facing catalog and search index. */
-export type Prepared<R = never> = {
-    readonly root: ToolNode<R>;
+export declare class ToolRuntimeError extends Error {
+    readonly kind: "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded";
+    readonly suggestions: ReadonlyArray<string>;
+    constructor(kind: "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded", message: string, suggestions?: ReadonlyArray<string>);
+}
+export declare const isBlockedMember: (name: string) => boolean;
+export declare const copyIn: (value: unknown, label: string, preserveCodeModeValues?: boolean) => unknown;
+export type CopyOutMode = "json" | "nullify";
+export declare const copyOut: (value: unknown, mode: CopyOutMode) => unknown;
+export type DiscoveryPlan = {
     readonly catalog: ReadonlyArray<ToolDescription>;
     readonly searchIndex: ReadonlyArray<SearchEntry>;
 };
@@ -57,13 +55,14 @@ export type SearchEntry = {
 };
 /** Exact callable signature of the built-in `search` function, for host-owned instructions. */
 export declare const searchSignature: string;
-export declare const prepare: <R>(tools: Tools<R>) => Prepared<R>;
+export declare const searchIndex: <R>(tools: Tools<R>) => ReadonlyArray<SearchEntry>;
+export declare const prepare: <R>(tools: Tools<R>) => DiscoveryPlan;
 export type ToolRuntime<R = never> = {
+    readonly root: ToolReference;
     readonly calls: Array<ToolCall>;
     readonly execute: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
     readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
     readonly keys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
 };
-/** Per-execution call state over tools prepared once for the runtime. */
-export declare const make: <R>(prepared: Prepared<R>, maxToolCalls: number | undefined, hooks?: ToolCallHooks<R>) => ToolRuntime<R>;
+export declare const make: <R>(tools: Tools<R>, maxToolCalls: number | undefined, searchIndex: ReadonlyArray<SearchEntry>, hooks?: ToolCallHooks<R>) => ToolRuntime<R>;
 export * as ToolRuntime from "./tool-runtime.js";