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

package/dist/stdlib/string.js

@@ -1,3 +1,6 @@
+import { sync } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { coercion } from "./value.js";
 export const stringMethods = new Set([
     "toLowerCase",
     "toUpperCase",
@@ -29,20 +32,15 @@ export const stringMethods = new Set([
     "localeCompare",
     "normalize",
 ]);
-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";
+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),
+    },
+});

package/dist/stdlib/url.d.ts

@@ -1,12 +1,16 @@
+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;
-export declare const invokeUriFunction: (ref: UriFunction, args: Array<unknown>, node: AstNode) => string;
+type UriFunction = "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
+export declare const uriGlobal: (name: UriFunction) => HostFunction<never>;
 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 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 {};

package/dist/stdlib/url.js

@@ -1,3 +1,11 @@
+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 { 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",
@@ -24,7 +32,6 @@ 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",
@@ -39,46 +46,116 @@ export const urlSearchParamsMethods = new Set([
     "entries",
     "toString",
 ]);
-export const uriArgument = (value, label) => coerceToString(boundedData(value, label));
-export const invokeUriFunction = (ref, args, node) => {
-    const value = uriArgument(args[0], `${ref.name} input`);
+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`);
     try {
-        switch (ref.name) {
-            case "encodeURI":
-                return encodeURI(value);
-            case "encodeURIComponent":
-                return encodeURIComponent(value);
-            case "decodeURI":
-                return decodeURI(value);
-            case "decodeURIComponent":
-                return decodeURIComponent(value);
-        }
+        return uriFunctions[name](value);
     }
     catch (error) {
-        throw new InterpreterRuntimeError(`${ref.name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
+        throw new InterpreterRuntimeError(`${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 invokeURLStatic = (name, args, node) => {
-    if (!urlStatics.has(name))
-        throw new InterpreterRuntimeError(`URL.${name} is not available.`, node);
-    if (args.length === 0)
+});
+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) {
         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 CodeModeURL(url);
+        return name === "canParse" ? true : new Values.URL(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());
+        const data = toProgram(init, "new URLSearchParams input");
+        if (data === null || typeof data !== "object") {
+            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(Object.entries(data).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,12 +1,13 @@
+import { type HostFunction, type SyncOptions } from "../interpreter/host.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";
+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 {};

package/dist/stdlib/value.js

@@ -1,3 +1,7 @@
+import { sync } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { toProgram } from "../data.js";
+import { Values } from "../values.js";
 export const errorConstructors = new Set([
     "Error",
     "TypeError",
@@ -8,7 +12,6 @@ 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) => {
@@ -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.
@@ -67,54 +69,53 @@ export const coerceToNumber = (value) => {
         return Number(coerceToString(value));
     return value !== null && typeof value === "object" ? Number.NaN : Number(value);
 };
-export const invokeCoercion = (ref, args, node) => {
+const coerce = (name, 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 (ref.name === "Number")
+        if (name === "Number")
             return 0;
-        if (ref.name === "String")
+        if (name === "String")
             return "";
     }
     const raw = args[0];
-    // Error values are plain SafeObjects; the boundedData path below would strip their brand.
-    if (ref.name === "String" && errorBrandName(raw) !== undefined)
+    // Error values are plain SafeObjects; the toProgram path below would strip their brand.
+    if (name === "String" && errorBrandName(raw) !== undefined)
         return coerceToString(raw);
-    if (isCodeModeValue(raw)) {
-        if (ref.name === "Boolean")
+    if (Values.isValue(raw)) {
+        if (name === "Boolean")
             return true;
-        if (ref.name === "Number")
+        if (name === "Number")
             return coerceToNumber(raw);
-        if (ref.name === "String")
+        if (name === "String")
             return coerceToString(raw);
-        if (ref.name === "isFinite")
+        if (name === "isFinite")
             return Number.isFinite(coerceToNumber(raw));
-        if (ref.name === "isNaN")
+        if (name === "isNaN")
             return Number.isNaN(coerceToNumber(raw));
-        if (ref.name === "parseInt")
+        if (name === "parseInt")
             return parseInt(coerceToString(raw));
         return parseFloat(coerceToString(raw));
     }
-    const value = boundedData(raw, `${ref.name} input`);
-    if (ref.name === "Number")
+    const value = toProgram(raw, `${name} input`);
+    if (name === "Number")
         return coerceToNumber(value);
-    if (ref.name === "Boolean")
+    if (name === "Boolean")
         return Boolean(value);
-    if (ref.name === "isFinite")
+    if (name === "isFinite")
         return Number.isFinite(coerceToNumber(value));
-    if (ref.name === "isNaN")
+    if (name === "isNaN")
         return Number.isNaN(coerceToNumber(value));
-    if (ref.name === "parseInt") {
+    if (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 (ref.name === "parseFloat")
+    if (name === "parseFloat")
         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";
+/** 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);

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";