@opencode/codemode 2.0.3 → 2.0.5

package/dist/stdlib/url.js

@@ -1,10 +1,9 @@
 import { Effect } from "effect";
-import { toProgram, ToolRuntimeError } from "../data.js";
 import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
-import { InterpreterRuntimeError, uriError } from "../interpreter/model.js";
-import { defineAccessor, entries, isWrapper, ProgramArray, ProgramObject, ProgramURL, ProgramURLSearchParams, } from "../interpreter/objects.js";
+import { PendingThrow, typeError, uriError } from "../interpreter/model.js";
+import { defineAccessor, entries, isWrapper, Arr, Obj, URLObj, URLSearchParamsObj } from "../interpreter/objects.js";
 import { isRuntimeReference } from "../interpreter/references.js";
-import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
+import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js";
 import { coerceToString } from "./value.js";
 const urlProperties = [
     "href",
@@ -19,64 +18,63 @@ const urlProperties = [
     "search",
     "hash",
 ];
-export const uriArgument = (protos, value, label) => coerceToString(toProgram(protos, value, label));
 const uriFunctions = {
     encodeURI,
     encodeURIComponent,
     decodeURI,
     decodeURIComponent,
 };
-export const uriGlobal = (runner, name) => fn(runner.prototypes, name, 1, (_, args, node) => {
-    const value = uriArgument(runner.prototypes, args[0], `${name} input`);
+export const uriGlobal = (ctx, name) => fn(ctx.builtins, name, 1, (_, args) => {
+    const value = coerceToString(args[0]);
     try {
         return uriFunctions[name](value);
     }
     catch (error) {
-        throw uriError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node);
+        throw uriError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`);
     }
 });
-const urlArgument = (protos, value, label) => value instanceof ProgramURL ? value.url.href : uriArgument(protos, value, label);
-export const urlGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.URL;
-    const construct = (args, into, node) => {
+const urlArgument = (value) => (value instanceof URLObj ? value.url.href : coerceToString(value));
+export const urlGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.URL;
+    const construct = (args, into) => {
         if (args.length === 0) {
-            throw new InterpreterRuntimeError("new URL(...) requires a URL string and an optional base URL.", node);
+            throw typeError("new URL(...) requires a URL string and an optional base URL.");
         }
-        const input = urlArgument(protos, args[0], "new URL input");
-        const base = args[1] === undefined ? undefined : urlArgument(protos, args[1], "new URL base");
+        const input = urlArgument(args[0]);
+        const base = args[1] === undefined ? undefined : urlArgument(args[1]);
         try {
-            return new ProgramURL(into, protos.URLSearchParams, new URL(input, base));
+            return new URLObj(into, builtins.URLSearchParams, new URL(input, base));
         }
         catch {
-            throw new InterpreterRuntimeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`, node);
+            throw typeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`);
         }
     };
-    const url = constructor(protos, proto, {
+    const url = constructor(builtins, proto, {
         name: "URL",
         length: 1,
         call: requiresNew("URL"),
-        construct: (args, newTarget, node) => Effect.sync(() => construct(args, prototypeFrom(newTarget, proto), node)),
+        construct: (args, newTarget) => Effect.sync(() => construct(args, prototypeFrom(newTarget, proto))),
     });
     const parse = (name) => [
         name,
         1,
-        (_, args, node) => {
+        (_, args) => {
             if (args.length === 0)
-                throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node);
-            const input = urlArgument(protos, args[0], `URL.${name} input`);
-            const base = args[1] === undefined ? undefined : urlArgument(protos, args[1], `URL.${name} base`);
+                throw typeError(`URL.${name} requires a URL argument.`);
+            const input = urlArgument(args[0]);
+            const base = args[1] === undefined ? undefined : urlArgument(args[1]);
             try {
                 const parsed = new URL(input, base);
-                return name === "canParse" ? true : new ProgramURL(proto, protos.URLSearchParams, parsed);
+                return name === "canParse" ? true : new URLObj(proto, builtins.URLSearchParams, parsed);
             }
             catch {
                 return name === "canParse" ? false : null;
             }
         },
     ];
-    methods(protos, url, [parse("canParse"), parse("parse")]);
-    const self = (thisValue, name, node) => receiver(ProgramURL, thisValue, `URL.prototype.${name}`, node);
+    methods(builtins, url, [parse("canParse"), parse("parse")]);
+    const self = (thisValue, name) => receiver(URLObj, thisValue, `URL.prototype.${name}`);
     for (const name of urlProperties) {
         defineAccessor(proto, name, (thisValue) => self(thisValue, name).url[name], name === "origin"
             ? undefined
@@ -84,40 +82,40 @@ export const urlGlobal = (runner) => {
                 const target = self(thisValue, name);
                 try {
                     ;
-                    target.url[name] = uriArgument(protos, value, `URL.${name} value`);
+                    target.url[name] = coerceToString(value);
                 }
                 catch (error) {
-                    if (error instanceof InterpreterRuntimeError || error instanceof ToolRuntimeError)
+                    if (error instanceof PendingThrow)
                         throw error;
-                    throw new InterpreterRuntimeError(`URL.${name} received an invalid value.`);
+                    throw typeError(`URL.${name} received an invalid value.`);
                 }
             });
     }
     defineAccessor(proto, "searchParams", (thisValue) => self(thisValue, "searchParams").searchParams);
-    methods(protos, proto, [
-        ["toString", 0, (thisValue, _, node) => self(thisValue, "toString", node).url.href],
-        ["toJSON", 0, (thisValue, _, node) => self(thisValue, "toJSON", node).url.href],
+    methods(builtins, proto, [
+        ["toString", 0, (thisValue) => self(thisValue, "toString").url.href],
+        ["toJSON", 0, (thisValue) => self(thisValue, "toJSON").url.href],
     ]);
     return url;
 };
-const readPair = (runner, value, node) => Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(value, node);
+const readPair = (ctx, value) => Effect.gen(function* () {
+    const cursor = yield* ctx.iterate(value);
     if (cursor === undefined) {
-        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node);
+        throw typeError("new URLSearchParams(...) expects iterable [name, value] pairs.");
     }
     const items = [];
     while (true) {
         const step = yield* cursor.next;
         if (step.done)
             return items;
-        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => uriArgument(runner.prototypes, step.value, "URLSearchParams pair value"))));
+        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => coerceToString(step.value))));
     }
 });
-const constructURLSearchParams = (runner, init, proto, node) => {
-    const wrap = (params) => new ProgramURLSearchParams(proto, params);
+const constructURLSearchParams = (ctx, init, proto) => {
+    const wrap = (params) => new URLSearchParamsObj(proto, params);
     if (init === undefined)
         return Effect.succeed(wrap(new URLSearchParams()));
-    if (init instanceof ProgramURLSearchParams)
+    if (init instanceof URLSearchParamsObj)
         return Effect.succeed(wrap(new URLSearchParams(init.params)));
     if (typeof init === "string")
         return Effect.succeed(wrap(new URLSearchParams(init)));
@@ -125,130 +123,128 @@ const constructURLSearchParams = (runner, init, proto, node) => {
         return Effect.succeed(wrap(new URLSearchParams(coerceToString(init))));
     }
     return Effect.gen(function* () {
-        const cursor = yield* runner.syncIterator(init, node);
+        const cursor = yield* ctx.iterate(init);
         if (cursor !== undefined) {
             const pairs = [];
             while (true) {
                 const step = yield* cursor.next;
                 if (step.done) {
                     if (pairs.some((entry) => entry.length !== 2)) {
-                        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node);
+                        throw typeError("new URLSearchParams(...) expects iterable [name, value] pairs.");
                     }
                     return wrap(new URLSearchParams(pairs.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
                 }
-                pairs.push(yield* preserveConsumerError(cursor, readPair(runner, step.value, node)));
+                pairs.push(yield* preserveConsumerError(cursor, readPair(ctx, step.value)));
             }
         }
         if (isRuntimeReference(init)) {
-            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node);
+            throw typeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.");
         }
         if (isWrapper(init))
             return wrap(new URLSearchParams());
-        if (!(init instanceof ProgramObject)) {
-            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node);
+        if (!(init instanceof Obj)) {
+            throw typeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.");
         }
         return wrap(new URLSearchParams(Object.fromEntries(entries(init).map(([key, value]) => [key, coerceToString(value)]))));
     });
 };
-export const urlSearchParamsGlobal = (runner) => {
-    const protos = runner.prototypes;
-    const proto = protos.URLSearchParams;
-    const searchParams = constructor(protos, proto, {
+export const urlSearchParamsGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.URLSearchParams;
+    const searchParams = constructor(builtins, proto, {
         name: "URLSearchParams",
         call: requiresNew("URLSearchParams"),
-        construct: (args, newTarget, node) => constructURLSearchParams(runner, args[0], prototypeFrom(newTarget, proto), node),
+        construct: (args, newTarget) => constructURLSearchParams(ctx, args[0], prototypeFrom(newTarget, proto)),
     });
-    const self = (thisValue, name, node) => receiver(ProgramURLSearchParams, thisValue, `URLSearchParams.prototype.${name}`, node);
-    const wrap = (items) => new ProgramArray(protos.Array, items);
-    const arg = (name, args, index) => uriArgument(protos, args[index], `URLSearchParams.${name} argument ${index + 1}`);
-    const requireArgs = (name, args, count, node) => {
+    const self = (thisValue, name) => receiver(URLSearchParamsObj, thisValue, `URLSearchParams.prototype.${name}`);
+    const wrap = (items) => new Arr(builtins.Array, items);
+    const arg = (args, index) => coerceToString(args[index]);
+    const requireArgs = (name, args, count) => {
         if (args.length < count) {
-            throw new InterpreterRuntimeError(`URLSearchParams.${name} requires ${count} argument${count === 1 ? "" : "s"}.`, node);
+            throw typeError(`URLSearchParams.${name} requires ${count} argument${count === 1 ? "" : "s"}.`);
         }
     };
     defineAccessor(proto, "size", (thisValue) => self(thisValue, "size").params.size);
-    methods(protos, proto, [
+    methods(builtins, proto, [
         [
             "append",
             2,
-            (thisValue, args, node) => {
-                requireArgs("append", args, 2, node);
-                self(thisValue, "append", node).params.append(arg("append", args, 0), arg("append", args, 1));
+            (thisValue, args) => {
+                requireArgs("append", args, 2);
+                self(thisValue, "append").params.append(arg(args, 0), arg(args, 1));
                 return undefined;
             },
         ],
         [
             "delete",
             1,
-            (thisValue, args, node) => {
-                requireArgs("delete", args, 1, node);
-                const params = self(thisValue, "delete", node).params;
+            (thisValue, args) => {
+                requireArgs("delete", args, 1);
+                const params = self(thisValue, "delete").params;
                 if (args[1] !== undefined)
-                    params.delete(arg("delete", args, 0), arg("delete", args, 1));
+                    params.delete(arg(args, 0), arg(args, 1));
                 else
-                    params.delete(arg("delete", args, 0));
+                    params.delete(arg(args, 0));
                 return undefined;
             },
         ],
         [
             "get",
             1,
-            (thisValue, args, node) => {
-                requireArgs("get", args, 1, node);
-                return self(thisValue, "get", node).params.get(arg("get", args, 0));
+            (thisValue, args) => {
+                requireArgs("get", args, 1);
+                return self(thisValue, "get").params.get(arg(args, 0));
             },
         ],
         [
             "getAll",
             1,
-            (thisValue, args, node) => {
-                requireArgs("getAll", args, 1, node);
-                return wrap(self(thisValue, "getAll", node).params.getAll(arg("getAll", args, 0)));
+            (thisValue, args) => {
+                requireArgs("getAll", args, 1);
+                return wrap(self(thisValue, "getAll").params.getAll(arg(args, 0)));
             },
         ],
         [
             "has",
             1,
-            (thisValue, args, node) => {
-                requireArgs("has", args, 1, node);
-                const params = self(thisValue, "has", node).params;
-                return args[1] !== undefined
-                    ? params.has(arg("has", args, 0), arg("has", args, 1))
-                    : params.has(arg("has", args, 0));
+            (thisValue, args) => {
+                requireArgs("has", args, 1);
+                const params = self(thisValue, "has").params;
+                return args[1] !== undefined ? params.has(arg(args, 0), arg(args, 1)) : params.has(arg(args, 0));
             },
         ],
         [
             "set",
             2,
-            (thisValue, args, node) => {
-                requireArgs("set", args, 2, node);
-                self(thisValue, "set", node).params.set(arg("set", args, 0), arg("set", args, 1));
+            (thisValue, args) => {
+                requireArgs("set", args, 2);
+                self(thisValue, "set").params.set(arg(args, 0), arg(args, 1));
                 return undefined;
             },
         ],
         [
             "sort",
             0,
-            (thisValue, _, node) => {
-                self(thisValue, "sort", node).params.sort();
+            (thisValue) => {
+                self(thisValue, "sort").params.sort();
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "keys", node).params.keys()))],
-        ["values", 0, (thisValue, _, node) => wrap(Array.from(self(thisValue, "values", node).params.values()))],
+        ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").params.keys()))],
+        ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").params.values()))],
         [
             "entries",
             0,
-            (thisValue, _, node) => wrap(Array.from(self(thisValue, "entries", node).params.entries(), ([key, value]) => wrap([key, value]))),
+            (thisValue) => wrap(Array.from(self(thisValue, "entries").params.entries(), ([key, value]) => wrap([key, value]))),
         ],
-        ["toString", 0, (thisValue, _, node) => self(thisValue, "toString", node).params.toString()],
+        ["toString", 0, (thisValue) => self(thisValue, "toString").params.toString()],
         [
             "forEach",
             1,
-            (thisValue, args, node) => {
-                requireArgs("forEach", args, 1, node);
-                const target = self(thisValue, "forEach", node);
-                const apply = applyCollectionCallback(runner, args[0], "URLSearchParams.forEach", node);
+            (thisValue, args) => {
+                requireArgs("forEach", args, 1);
+                const target = self(thisValue, "forEach");
+                const apply = applyCollectionCallback(ctx, args[0], "URLSearchParams.forEach");
                 return Effect.gen(function* () {
                     for (const [key, value] of Array.from(target.params.entries()))
                         yield* apply([value, key, target]);

package/dist/stdlib/value.d.ts

@@ -1,9 +1,9 @@
-import { type NativeFunction } from "../interpreter/objects.js";
-import type { Runner } from "../interpreter/runner.js";
+import { type Native } from "../interpreter/objects.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
 export declare const compoundOperators: Set<string>;
 /** The built-in string form of a value, without consulting program-defined `toString` methods. */
 export declare const coerceToString: (value: unknown) => string;
 export declare const coerceToNumber: (value: unknown) => number;
 export type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
 /** A global coercion function such as `Number` or `parseInt`. */
-export declare const coercion: <R>(runner: Runner<R>, name: Coercion, length?: number) => NativeFunction<R>;
+export declare const coercion: <R>(ctx: Interpreter<R>, name: Coercion, length?: number) => Native<R>;

package/dist/stdlib/value.js

@@ -1,7 +1,6 @@
-import { toProgram } from "../data.js";
 import { fn } from "../interpreter/native.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { get, isWrapper, ProgramArray, ProgramDate, ProgramError, ProgramMap, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "../interpreter/objects.js";
+import { typeError } from "../interpreter/model.js";
+import { get, isWrapper, Arr, Bytes, DateObj, ErrorObj, MapObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, } from "../interpreter/objects.js";
 export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="]);
 /** The built-in string form of a value, without consulting program-defined `toString` methods. */
 export const coerceToString = (value) => {
@@ -9,19 +8,21 @@ export const coerceToString = (value) => {
         return "null";
     if (value === undefined)
         return "undefined";
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date";
-    if (value instanceof ProgramRegExp)
+    if (value instanceof RegExpObj)
         return `/${value.regex.source}/${value.regex.flags}`;
-    if (value instanceof ProgramMap)
+    if (value instanceof MapObj)
         return "[object Map]";
-    if (value instanceof ProgramSet)
+    if (value instanceof SetObj)
         return "[object Set]";
-    if (value instanceof ProgramURL)
+    if (value instanceof URLObj)
         return value.url.href;
-    if (value instanceof ProgramURLSearchParams)
+    if (value instanceof URLSearchParamsObj)
         return value.params.toString();
-    if (value instanceof ProgramError) {
+    if (value instanceof Bytes)
+        return value.bytes.join(",");
+    if (value instanceof ErrorObj) {
         // Match Error.prototype.toString: "name: message", or just one when the other is empty.
         const name = get(value, "name");
         const message = get(value, "message");
@@ -33,7 +34,7 @@ export const coerceToString = (value) => {
             return shownMessage;
         return `${shownName}: ${shownMessage}`;
     }
-    if (value instanceof ProgramArray) {
+    if (value instanceof Arr) {
         return value.items.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",");
     }
     if (typeof value === "object")
@@ -41,15 +42,17 @@ export const coerceToString = (value) => {
     return String(value);
 };
 export const coerceToNumber = (value) => {
-    if (value instanceof ProgramDate)
+    if (value instanceof DateObj)
         return value.time;
+    if (value instanceof Bytes)
+        return Number(coerceToString(value));
     if (isWrapper(value))
         return Number.NaN;
-    if (value instanceof ProgramArray)
+    if (value instanceof Arr)
         return Number(coerceToString(value));
     return value !== null && typeof value === "object" ? Number.NaN : Number(value);
 };
-const coerce = (runner, name, args, node) => {
+const coerce = (ctx, name, args) => {
     // 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) {
@@ -74,25 +77,24 @@ const coerce = (runner, name, args, node) => {
             return parseInt(coerceToString(raw));
         return parseFloat(coerceToString(raw));
     }
-    const value = toProgram(runner.prototypes, raw, `${name} input`);
     if (name === "Number")
-        return coerceToNumber(value);
+        return coerceToNumber(raw);
     if (name === "Boolean")
-        return Boolean(value);
+        return Boolean(raw);
     if (name === "isFinite")
-        return Number.isFinite(coerceToNumber(value));
+        return Number.isFinite(coerceToNumber(raw));
     if (name === "isNaN")
-        return Number.isNaN(coerceToNumber(value));
+        return Number.isNaN(coerceToNumber(raw));
     if (name === "parseInt") {
         const radix = args[1];
         if (radix !== undefined && typeof radix !== "number") {
-            throw new InterpreterRuntimeError("parseInt expects a numeric radix.", node);
+            throw typeError("parseInt expects a numeric radix.");
         }
-        return parseInt(coerceToString(value), radix);
+        return parseInt(coerceToString(raw), radix);
     }
     if (name === "parseFloat")
-        return parseFloat(coerceToString(value));
-    return coerceToString(value);
+        return parseFloat(coerceToString(raw));
+    return coerceToString(raw);
 };
 /** A global coercion function such as `Number` or `parseInt`. */
-export const coercion = (runner, name, length = 1) => fn(runner.prototypes, name, length, (_, args, node) => toProgram(runner.prototypes, coerce(runner, name, args, node), `${name} result`));
+export const coercion = (ctx, name, length = 1) => fn(ctx.builtins, name, length, (_, args) => coerce(ctx, name, args));

package/dist/stdlib/web.d.ts

@@ -1,4 +1,4 @@
-import { ProgramObject } from "../interpreter/objects.js";
-import type { Runner } from "../interpreter/runner.js";
-export declare const base64Global: <R>(runner: Runner<R>, name: "atob" | "btoa") => import("../interpreter/objects.js").NativeFunction<R>;
-export declare const cryptoGlobal: <R>(runner: Runner<R>) => ProgramObject;
+import { Obj } from "../interpreter/objects.js";
+import type { Interpreter } from "../interpreter/interpreter.js";
+export declare const base64Global: <R>(ctx: Interpreter<R>, name: "atob" | "btoa") => import("../interpreter/objects.js").Native<R>;
+export declare const cryptoGlobal: <R>(ctx: Interpreter<R>) => Obj;

package/dist/stdlib/web.js

@@ -1,22 +1,36 @@
 import { fn, methods } from "../interpreter/native.js";
-import { InterpreterRuntimeError } from "../interpreter/model.js";
-import { ProgramObject } from "../interpreter/objects.js";
+import { typeError } from "../interpreter/model.js";
+import { Bytes, Obj } from "../interpreter/objects.js";
+import { describeValue } from "../interpreter/references.js";
 import { coerceToString } from "./value.js";
 // WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies. Invalid input is a
 // TypeError as well; browsers throw a DOMException named InvalidCharacterError, which CodeMode does not have.
-export const base64Global = (runner, name) => fn(runner.prototypes, name, 1, (_, args, node) => {
+export const base64Global = (ctx, name) => fn(ctx.builtins, name, 1, (_, args) => {
     if (args.length === 0)
-        throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node);
+        throw typeError(`${name} requires 1 argument (a string)`);
     const input = coerceToString(args[0]);
     try {
         return name === "atob" ? atob(input) : btoa(input);
     }
     catch {
-        throw new InterpreterRuntimeError("The string contains invalid characters.", node);
+        throw typeError("The string contains invalid characters.");
     }
 });
-export const cryptoGlobal = (runner) => {
-    const object = new ProgramObject(runner.prototypes.Object);
-    methods(runner.prototypes, object, [["randomUUID", 0, () => crypto.randomUUID()]]);
+export const cryptoGlobal = (ctx) => {
+    const object = new Obj(ctx.builtins.Object);
+    methods(ctx.builtins, object, [
+        ["randomUUID", 0, () => crypto.randomUUID()],
+        [
+            "getRandomValues",
+            1,
+            (_, args) => {
+                if (!(args[0] instanceof Bytes)) {
+                    throw typeError(`crypto.getRandomValues expects a Uint8Array, received ${describeValue(args[0])}.`);
+                }
+                crypto.getRandomValues(args[0].bytes);
+                return args[0];
+            },
+        ],
+    ]);
     return object;
 };

package/dist/tool-runtime.d.ts

@@ -1,9 +1,10 @@
 import { Effect } from "effect";
-import type { Prototypes } from "./interpreter/intrinsics.js";
+import type { Json } from "./data.js";
+import type { DiagnosticKind } from "./codemode.js";
 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 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";
@@ -12,25 +13,36 @@ type ServicesOf<T, Depth extends ReadonlyArray<unknown>> = Depth["length"] exten
 export type ToolCall = {
     readonly name: string;
 };
-export type ToolCallStarted = {
-    readonly index: number;
+/** A tool call the program is making, with its decoded input. */
+export type ToolInvocation = {
     readonly name: string;
     readonly input: unknown;
 };
-export type ToolCallEnded = {
-    readonly index: number;
+/** A call the program is making to an extension global, with its arguments. */
+export type ExtensionInvocation = {
+    readonly extension: string;
     readonly name: string;
-    readonly input: unknown;
-    readonly durationMs: number;
-    readonly outcome: "success" | "failure" | "interrupted";
-    readonly message?: string;
+    readonly args: ReadonlyArray<unknown>;
+};
+/** How a call ended; `after` hooks observe it and cannot change it. */
+export type CallResult = {
+    readonly status: "success";
+    readonly value: unknown;
+} | {
+    readonly status: "failure";
+    readonly error: unknown;
+} | {
+    readonly status: "interrupted";
 };
-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;
+/** Hooks around every call the program makes into the host. A failing `before` denies the call. */
+export type Hooks<R = never> = {
+    readonly "tool.before"?: ((call: ToolInvocation) => Effect.Effect<void, unknown, R>) | undefined;
+    readonly "tool.after"?: ((call: ToolInvocation, result: CallResult) => Effect.Effect<void, never, R>) | undefined;
+    readonly "extension.before"?: ((call: ExtensionInvocation) => Effect.Effect<void, unknown, R>) | undefined;
+    readonly "extension.after"?: ((call: ExtensionInvocation, result: CallResult) => Effect.Effect<void, never, R>) | undefined;
 };
+/** Runs `before`, then `run`, then `after` with how it ended, including when interrupted. */
+export declare const hooked: <Call, A, R>(call: Call, before: ((call: Call) => Effect.Effect<void, unknown, R>) | undefined, after: ((call: Call, result: CallResult) => Effect.Effect<void, never, R>) | undefined, run: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
 export type ToolDescription = {
     readonly path: string;
     readonly description: string;
@@ -46,7 +58,7 @@ type ToolNode<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. */
+/** Tools indexed once per runtime, with discovery materialized on demand. */
 export type Prepared<R = never> = {
     readonly root: ToolNode<R>;
     readonly catalog: ReadonlyArray<ToolDescription>;
@@ -59,12 +71,19 @@ 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 class ToolRuntimeError extends Error {
+    readonly kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "ToolCallLimitExceeded">;
+    readonly suggestions: ReadonlyArray<string>;
+    constructor(kind: Extract<DiagnosticKind, "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "ToolCallLimitExceeded">, message: string, suggestions?: ReadonlyArray<string>);
+}
+/** The tool bridge of one execution. Arguments arrive and results leave as JSON; program values never enter. */
 export type ToolRuntime<R = never> = {
     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 hooks: Hooks<R>;
+    readonly execute: (path: ReadonlyArray<string>, args: Array<Json | undefined>) => Effect.Effect<Json | undefined, unknown, R>;
+    readonly search: (args: Array<Json | undefined>) => Effect.Effect<Json | undefined, 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>, prototypes: Prototypes, maxToolCalls: number | undefined, hooks?: ToolCallHooks<R>) => ToolRuntime<R>;
+export declare const make: <R>(prepared: Prepared<R>, maxToolCalls: number | undefined, hooks?: Hooks<R>) => ToolRuntime<R>;
 export * as ToolRuntime from "./tool-runtime.js";