@opencode/codemode 0.0.0-beta-19289 → 0.0.0-beta-19365

package/dist/openapi/spec.js

@@ -1,5 +1,5 @@
 import { fromSchemaOpenApi3_0, fromSchemaOpenApi3_1 } from "effect/JsonSchema";
-import { isBlockedMember } from "../tool-runtime.js";
+import { isBlockedMember } from "../data.js";
 export const methods = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
 const parameterLocations = ["path", "query", "header"];
 const ignoredHeaderParameters = new Set(["accept", "content-type", "authorization"]);

package/dist/stdlib/console.js

@@ -1,7 +1,7 @@
+import { toData, toProgram } from "../data.js";
 import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
-import { copyIn, copyOut } from "../tool-runtime.js";
-import { isCodeModeValue, CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
-import { boundedData, coerceToString } from "./value.js";
+import { Values } from "../values.js";
+import { coerceToString } from "./value.js";
 export const consoleMethods = new Set(["log", "info", "debug", "warn", "error", "dir", "table"]);
 const MAX_CONSOLE_DEPTH = 32;
 export const formatConsoleMessage = (name, args) => {
@@ -28,21 +28,21 @@ const formatConsoleValue = (value, seen, depth) => {
         return String(value);
     if (typeof value !== "object")
         return String(value);
-    if (value instanceof CodeModePromise)
+    if (value instanceof Values.Promise)
         return "[Promise (await it to get its value)]";
-    if (value instanceof CodeModeDate)
+    if (value instanceof Values.Date)
         return coerceToString(value);
-    if (value instanceof CodeModeRegExp)
+    if (value instanceof Values.RegExp)
         return coerceToString(value);
-    if (value instanceof CodeModeURL)
+    if (value instanceof Values.URL)
         return coerceToString(value);
-    if (value instanceof CodeModeURLSearchParams)
+    if (value instanceof Values.URLSearchParams)
         return coerceToString(value);
     if (depth > MAX_CONSOLE_DEPTH)
         return "...";
     if (seen.has(value))
         return "[Circular]";
-    if (value instanceof CodeModeMap) {
+    if (value instanceof Values.Map) {
         seen.add(value);
         try {
             const entries = Array.from(value.map.entries(), ([key, item]) => [key, item]);
@@ -52,7 +52,7 @@ const formatConsoleValue = (value, seen, depth) => {
             seen.delete(value);
         }
     }
-    if (value instanceof CodeModeSet) {
+    if (value instanceof Values.Set) {
         seen.add(value);
         try {
             return `Set(${value.set.size}) ${formatConsoleValue(Array.from(value.set.values()), seen, depth + 1)}`;
@@ -81,7 +81,7 @@ const formatConsoleTable = (value, columnsArgument) => {
         return "undefined";
     if (containsOpaqueReference(value))
         return "[opaque reference]";
-    const data = boundedData(value, "console.table argument");
+    const data = toProgram(value, "console.table argument");
     const columns = consoleTableColumns(columnsArgument);
     const rows = consoleTableRows(data, columns);
     const keys = columns ?? Array.from(new Set(rows.flatMap((row) => Object.keys(row.values))));
@@ -96,20 +96,20 @@ const consoleTableColumns = (value) => {
         return undefined;
     if (containsRuntimeReference(value))
         return undefined;
-    const columns = copyOut(copyIn(value, "console.table columns"), "nullify");
+    const columns = toData(value, "console.table columns", "result");
     return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined;
 };
 const consoleTableRows = (data, columns) => {
     if (Array.isArray(data)) {
         return data.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
     }
-    if (data !== null && typeof data === "object" && !isCodeModeValue(data)) {
+    if (data !== null && typeof data === "object" && !Values.isValue(data)) {
         return Object.entries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
     }
     return [{ index: "0", values: { Value: data } }];
 };
 const consoleTableValues = (value, columns) => {
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && !isCodeModeValue(value)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && !Values.isValue(value)) {
         const source = value;
         if (columns !== undefined)
             return Object.fromEntries(columns.map((column) => [column, source[column]]));

package/dist/stdlib/date.d.ts

@@ -1,7 +1,7 @@
 import { type AstNode } from "../interpreter/model.js";
-import { CodeModeDate } from "../values.js";
+import { Values } from "../values.js";
 export declare const dateMethods: Set<string>;
 export declare const dateStatics: Set<string>;
 export declare const invokeDateStatic: (name: string, args: Array<unknown>, node: AstNode) => number;
 export declare const dateSetterArgumentCount: (name: string) => number | undefined;
-export declare const invokeDateMethod: (value: CodeModeDate, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;
+export declare const invokeDateMethod: (value: Values.Date, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;

package/dist/stdlib/date.js

@@ -1,5 +1,5 @@
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { CodeModeDate } from "../values.js";
+import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 const dateSetterArguments = new Map([
     ["setTime", 1],

package/dist/stdlib/json.js

@@ -2,8 +2,8 @@ import { Effect } from "effect";
 import { applyCollectionCallback } from "../interpreter/methods.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
-import { copyIn, copyOut } from "../tool-runtime.js";
-import { CodeModeDate, CodeModeMap, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "../values.js";
+import { fromData, toData, toProgram } from "../data.js";
+import { Values } from "../values.js";
 export const jsonStatics = new Set(["parse", "stringify"]);
 export const invokeJsonMethod = (runner, name, args, node) => {
     return name === "parse" ? parse(runner, args, node) : stringify(runner, args, node);
@@ -14,7 +14,7 @@ const parse = (runner, args, node) => {
         throw new InterpreterRuntimeError("JSON.parse expects a string.", node);
     const parsed = (() => {
         try {
-            return copyIn(JSON.parse(text), "JSON.parse result");
+            return fromData(JSON.parse(text), "JSON.parse result");
         }
         catch (error) {
             throw new InterpreterRuntimeError(`JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`, node).as("SyntaxError");
@@ -54,27 +54,25 @@ const stringify = (runner, args, node) => {
     const space = args[2];
     const indent = typeof space === "number" || typeof space === "string" ? space : undefined;
     const replacer = args[1];
-    const callable = typeofValue(replacer) === "function";
-    const checked = copyIn(args[0], "JSON.stringify value", callable);
-    const input = callable ? args[0] : checked;
-    if (Array.isArray(replacer)) {
-        const properties = replacer
-            .filter((item) => typeof item === "string" || typeof item === "number")
-            .map(String);
-        return Effect.succeed(JSON.stringify(copyOut(input, "json"), properties, indent));
-    }
-    if (!callable) {
-        return Effect.succeed(JSON.stringify(copyOut(input, "json"), null, indent));
+    if (typeofValue(replacer) !== "function") {
+        const properties = Array.isArray(replacer)
+            ? replacer
+                .filter((item) => typeof item === "string" || typeof item === "number")
+                .map(String)
+            : null;
+        return Effect.succeed(JSON.stringify(toData(args[0], "JSON.stringify value"), properties, indent));
     }
+    // Validate up front; the replacer walk below reads the original value.
+    toProgram(args[0], "JSON.stringify value");
     const apply = applyCollectionCallback(runner, replacer, "JSON.stringify", node);
     const root = Object.create(null);
-    root[""] = input;
+    root[""] = args[0];
     const stack = new Set();
     const visit = (holder, key) => Effect.gen(function* () {
         const value = yield* apply([key, toJSONValue(holder[key])]);
         if (value === undefined || typeofValue(value) === "function")
             return undefined;
-        copyIn(value, "JSON.stringify replacer result", true);
+        toProgram(value, "JSON.stringify replacer result");
         if (typeof value === "number")
             return Number.isFinite(value) ? value : null;
         if (value === null || typeof value === "string" || typeof value === "boolean")
@@ -107,18 +105,11 @@ const stringify = (runner, args, node) => {
     return Effect.map(visit(root, ""), (value) => JSON.stringify(value, null, indent));
 };
 const toJSONValue = (value) => {
-    if (value instanceof CodeModeDate) {
+    if (value instanceof Values.Date) {
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null;
     }
-    if (value instanceof CodeModeURL)
+    if (value instanceof Values.URL)
         return value.url.href;
     return value;
 };
-const isPlainObject = (value) => value !== null &&
-    typeof value === "object" &&
-    !(value instanceof CodeModeDate) &&
-    !(value instanceof CodeModeRegExp) &&
-    !(value instanceof CodeModeMap) &&
-    !(value instanceof CodeModeSet) &&
-    !(value instanceof CodeModeURL) &&
-    !(value instanceof CodeModeURLSearchParams);
+const isPlainObject = (value) => value !== null && typeof value === "object" && !Values.isValue(value);

package/dist/stdlib/number.d.ts

@@ -1,6 +1,6 @@
+import { type AstNode } from "../interpreter/model.js";
 export declare const numberMethods: Set<string>;
 export declare const numberConstants: Set<string>;
 export declare const numberStatics: Set<string>;
 export declare const invokeNumberMethod: (value: number, name: string, args: Array<unknown>, node: AstNode) => unknown;
 export declare const invokeNumberStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
-import { type AstNode } from "../interpreter/model.js";

package/dist/stdlib/number.js

@@ -1,3 +1,6 @@
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { toProgram } from "../data.js";
+import { coerceToString } from "./value.js";
 export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString", "valueOf"]);
 export const numberConstants = new Set([
     "MAX_SAFE_INTEGER",
@@ -46,7 +49,7 @@ export const invokeNumberMethod = (value, name, args, node) => {
         default:
             throw new InterpreterRuntimeError(`Number method '${name}' is not available.`, node);
     }
-    return boundedData(result, `Number.${name} result`);
+    return toProgram(result, `Number.${name} result`);
 };
 export const invokeNumberStatic = (name, args, node) => {
     const value = args[0];
@@ -72,5 +75,3 @@ export const invokeNumberStatic = (name, args, node) => {
             throw new InterpreterRuntimeError(`Number.${name} is not available.`, node);
     }
 };
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { boundedData, coerceToString } from "./value.js";

package/dist/stdlib/object.js

@@ -1,9 +1,10 @@
 import { Effect } from "effect";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "../interpreter/model.js";
 import { containsOpaqueReference, rejectCircularInsertion } from "../interpreter/references.js";
-import { isBlockedMember } from "../tool-runtime.js";
-import { isCodeModeValue, CodeModePromise } from "../values.js";
-import { boundedData, coerceToString } from "./value.js";
+import { isBlockedMember } from "../data.js";
+import { Values } from "../values.js";
+import { toProgram } from "../data.js";
+import { coerceToString } from "./value.js";
 import { preserveConsumerError } from "../interpreter/iterator.js";
 export const objectMethodsPreservingIdentity = new Set(["assign", "values", "entries", "fromEntries"]);
 export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "is", "assign", "fromEntries", "groupBy"]);
@@ -12,9 +13,9 @@ export const invokeObjectMethod = (name, args, node) => {
         const input = args[0];
         if (Array.isArray(input))
             return input;
-        if (isCodeModeValue(input))
+        if (Values.isValue(input))
             return {};
-        if (input instanceof CodeModePromise) {
+        if (input instanceof Values.Promise) {
             throw new InterpreterRuntimeError(`Object.${name} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
         }
         if (input === null || typeof input !== "object") {
@@ -42,7 +43,7 @@ export const invokeObjectMethod = (name, args, node) => {
             return Object.is(args[0], args[1]);
         case "assign": {
             const target = args[0];
-            if (target === null || typeof target !== "object" || Array.isArray(target) || isCodeModeValue(target)) {
+            if (target === null || typeof target !== "object" || Array.isArray(target) || Values.isValue(target)) {
                 throw new InterpreterRuntimeError("Object.assign expects a data object target.", node);
             }
             const out = target;
@@ -55,7 +56,7 @@ export const invokeObjectMethod = (name, args, node) => {
                     throw new InterpreterRuntimeError(`Object.assign could not assign property '${String(key)}'.`, node).as("TypeError");
             };
             for (const source of args.slice(1)) {
-                if (source === null || source === undefined || isCodeModeValue(source))
+                if (source === null || source === undefined || Values.isValue(source))
                     continue;
                 if (typeof source !== "object" || Array.isArray(source)) {
                     throw new InterpreterRuntimeError("Object.assign expects data objects.", node);
@@ -92,13 +93,13 @@ export const invokeObjectFromEntries = (runner, source, node) => {
             yield* preserveConsumerError(cursor, Effect.sync(() => {
                 if (step.value === null ||
                     typeof step.value !== "object" ||
-                    isCodeModeValue(step.value) ||
+                    Values.isValue(step.value) ||
                     containsOpaqueReference(step.value)) {
                     throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as("TypeError");
                 }
                 const entry = step.value;
-                boundedData(entry[0], "Object.fromEntries key");
-                boundedData(entry[1], "Object.fromEntries value");
+                toProgram(entry[0], "Object.fromEntries key");
+                toProgram(entry[1], "Object.fromEntries value");
                 const key = coerceToString(entry[0]);
                 if (isBlockedMember(key))
                     throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);

package/dist/stdlib/regexp.d.ts

@@ -1,5 +1,5 @@
 import { type AstNode } from "../interpreter/model.js";
-import { CodeModeRegExp } from "../values.js";
+import { Values } from "../values.js";
 export declare const regexpMethods: Set<string>;
 export declare const regexpStatics: Set<string>;
 export declare const regexpProperties: Set<string>;
@@ -8,4 +8,4 @@ export declare const escapeRegexHint = "To match special characters like ( ) [ ]
 export declare const toHostRegex: (arg: unknown, method: string, node: AstNode, extraFlags?: string) => RegExp;
 export declare const matchToValue: (match: RegExpMatchArray) => Array<unknown>;
 export declare const invokeRegExpStatic: (name: string, args: Array<unknown>, node: AstNode) => string;
-export declare const invokeRegExpMethod: (value: CodeModeRegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const invokeRegExpMethod: (value: Values.RegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;

package/dist/stdlib/regexp.js

@@ -1,6 +1,6 @@
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { isBlockedMember } from "../tool-runtime.js";
-import { CodeModeRegExp } from "../values.js";
+import { isBlockedMember } from "../data.js";
+import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 export const regexpMethods = new Set(["test", "exec", "toString"]);
 export const regexpStatics = new Set(["escape"]);
@@ -23,7 +23,7 @@ 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 CodeModeRegExp)
+    if (arg instanceof Values.RegExp)
         return arg.regex;
     if (typeof arg === "string") {
         try {

package/dist/stdlib/string.d.ts

@@ -1,4 +1,4 @@
+import { type AstNode } from "../interpreter/model.js";
 export declare const stringMethods: Set<string>;
 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,3 +1,4 @@
+import { InterpreterRuntimeError } from "../interpreter/model.js";
 export const stringMethods = new Set([
     "toLowerCase",
     "toUpperCase",
@@ -45,4 +46,3 @@ export const invokeStringStatic = (name, args, node) => {
             throw new InterpreterRuntimeError(`String.${name} is not available.`, node);
     }
 };
-import { InterpreterRuntimeError } from "../interpreter/model.js";

package/dist/stdlib/url.d.ts

@@ -1,3 +1,5 @@
+import { type AstNode, UriFunction } from "../interpreter/model.js";
+import { Values } from "../values.js";
 export declare const urlProperties: Set<string>;
 export declare const urlWritableProperties: Set<string>;
 export declare const urlMethods: Set<string>;
@@ -7,6 +9,4 @@ export declare const uriArgument: (value: unknown, label: string) => string;
 export declare const invokeUriFunction: (ref: UriFunction, args: Array<unknown>, node: AstNode) => string;
 export declare const urlArgument: (value: unknown, label: string) => string;
 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";
+export declare const invokeURLMethod: (value: Values.URL, name: string, node: AstNode) => string;

package/dist/stdlib/url.js

@@ -1,3 +1,7 @@
+import { InterpreterRuntimeError, UriFunction } from "../interpreter/model.js";
+import { Values } from "../values.js";
+import { toProgram } from "../data.js";
+import { coerceToString } from "./value.js";
 export const urlProperties = new Set([
     "href",
     "origin",
@@ -39,7 +43,7 @@ export const urlSearchParamsMethods = new Set([
     "entries",
     "toString",
 ]);
-export const uriArgument = (value, label) => coerceToString(boundedData(value, label));
+export const uriArgument = (value, label) => coerceToString(toProgram(value, label));
 export const invokeUriFunction = (ref, args, node) => {
     const value = uriArgument(args[0], `${ref.name} input`);
     try {
@@ -58,7 +62,7 @@ export const invokeUriFunction = (ref, args, node) => {
         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 CodeModeURL ? value.url.href : uriArgument(value, label);
+export const urlArgument = (value, label) => value instanceof Values.URL ? 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);
@@ -68,7 +72,7 @@ export const invokeURLStatic = (name, args, node) => {
     const base = args[1] === undefined ? undefined : urlArgument(args[1], `URL.${name} base`);
     try {
         const url = new URL(input, base);
-        return name === "canParse" ? true : new CodeModeURL(url);
+        return name === "canParse" ? true : new Values.URL(url);
     }
     catch {
         return name === "canParse" ? false : null;
@@ -79,6 +83,3 @@ export const invokeURLMethod = (value, name, node) => {
         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,12 +1,11 @@
+import { type AstNode, CoercionFunction } from "../interpreter/model.js";
+import { type SafeObject } from "../data.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) => 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;
 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,3 +1,6 @@
+import { CoercionFunction, InterpreterRuntimeError } from "../interpreter/model.js";
+import { toProgram } from "../data.js";
+import { Values } from "../values.js";
 export const errorConstructors = new Set([
     "Error",
     "TypeError",
@@ -20,23 +23,22 @@ export const createAggregateErrorValue = (errors, message) => Object.assign(crea
 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 CodeModeDate)
+    if (value instanceof Values.Date)
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date";
-    if (value instanceof CodeModeRegExp)
+    if (value instanceof Values.RegExp)
         return `/${value.regex.source}/${value.regex.flags}`;
-    if (value instanceof CodeModeMap)
+    if (value instanceof Values.Map)
         return "[object Map]";
-    if (value instanceof CodeModeSet)
+    if (value instanceof Values.Set)
         return "[object Set]";
-    if (value instanceof CodeModeURL)
+    if (value instanceof Values.URL)
         return value.url.href;
-    if (value instanceof CodeModeURLSearchParams)
+    if (value instanceof Values.URLSearchParams)
         return value.params.toString();
     if (errorBrandName(value) !== undefined) {
         // Match Error.prototype.toString: "name: message", or just one when the other is empty.
@@ -57,9 +59,9 @@ export const coerceToString = (value) => {
     return String(value);
 };
 export const coerceToNumber = (value) => {
-    if (value instanceof CodeModeDate)
+    if (value instanceof Values.Date)
         return value.time;
-    if (isCodeModeValue(value))
+    if (Values.isValue(value))
         return Number.NaN;
     // Arrays coerce through our own string coercion: host Number(array) joins with host
     // ToPrimitive, which throws on the null-prototype objects the interpreter produces.
@@ -77,10 +79,10 @@ export const invokeCoercion = (ref, args, node) => {
             return "";
     }
     const raw = args[0];
-    // Error values are plain SafeObjects; the boundedData path below would strip their brand.
+    // Error values are plain SafeObjects; the toProgram path below would strip their brand.
     if (ref.name === "String" && errorBrandName(raw) !== undefined)
         return coerceToString(raw);
-    if (isCodeModeValue(raw)) {
+    if (Values.isValue(raw)) {
         if (ref.name === "Boolean")
             return true;
         if (ref.name === "Number")
@@ -95,7 +97,7 @@ export const invokeCoercion = (ref, args, node) => {
             return parseInt(coerceToString(raw));
         return parseFloat(coerceToString(raw));
     }
-    const value = boundedData(raw, `${ref.name} input`);
+    const value = toProgram(raw, `${ref.name} input`);
     if (ref.name === "Number")
         return coerceToNumber(value);
     if (ref.name === "Boolean")
@@ -115,6 +117,3 @@ export const invokeCoercion = (ref, args, node) => {
         return parseFloat(coerceToString(value));
     return coerceToString(value);
 };
-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,5 +1,8 @@
 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) => 0 | 1 | -1;
 export type Services<T> = ServicesOf<T, []>;
 type ServicesOf<T, Depth extends ReadonlyArray<unknown>> = Depth["length"] extends 8 ? never : T extends {
     readonly _tag: "CodeModeTool";
@@ -22,7 +25,9 @@ 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 = {
@@ -30,22 +35,19 @@ 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>);
 }
-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 = {
+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>;
     readonly catalog: ReadonlyArray<ToolDescription>;
     readonly searchIndex: ReadonlyArray<SearchEntry>;
 };
@@ -55,14 +57,13 @@ export type SearchEntry = {
 };
 /** Exact callable signature of the built-in `search` function, for host-owned instructions. */
 export declare const searchSignature: string;
-export declare const searchIndex: <R>(tools: Tools<R>) => ReadonlyArray<SearchEntry>;
-export declare const prepare: <R>(tools: Tools<R>) => DiscoveryPlan;
+export declare const prepare: <R>(tools: Tools<R>) => Prepared<R>;
 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>;
 };
-export declare const make: <R>(tools: Tools<R>, maxToolCalls: number | undefined, searchIndex: ReadonlyArray<SearchEntry>, hooks?: ToolCallHooks<R>) => ToolRuntime<R>;
+/** 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 * as ToolRuntime from "./tool-runtime.js";