@opencode/codemode 2.0.11 → 2.0.13

package/dist/stdlib/json.js

@@ -2,10 +2,10 @@ import { Effect } from "effect";
 import { methods } from "../interpreter/native.js";
 import { applyCollectionCallback } from "../interpreter/callback.js";
 import { checkStringLength } from "../interpreter/limits.js";
-import { syntaxError, typeError } from "../interpreter/model.js";
+import { syntaxError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { fromJson, toJson } from "../data.js";
-import { get, keys, Arr, Obj, record, remove, set } from "../interpreter/objects.js";
+import { get, keys, Arr, Obj, coerceToString, record, remove, set } from "../interpreter/objects.js";
 export const jsonGlobal = (ctx) => {
     const json = new Obj(ctx.builtins.Object);
     methods(ctx.builtins, json, [
@@ -15,9 +15,7 @@ export const jsonGlobal = (ctx) => {
     return json;
 };
 const parse = (ctx, args) => {
-    const text = args[0];
-    if (typeof text !== "string")
-        throw typeError("JSON.parse expects a string.");
+    const text = coerceToString(args[0]);
     const parsed = (() => {
         try {
             return fromJson(ctx, JSON.parse(text));

package/dist/stdlib/math.js

@@ -1,32 +1,20 @@
 import { Effect } from "effect";
 import { constants, methods } from "../interpreter/native.js";
 import { typeError } from "../interpreter/model.js";
-import { Obj } from "../interpreter/objects.js";
+import { Obj, coerceToNumber } from "../interpreter/objects.js";
 import { preserveConsumerError } from "../interpreter/callback.js";
 // Validate only the arguments a method consumes; like JS, extras are ignored
 // (so built-ins work as callbacks receiving (element, index, array)).
-const number = (name, args, index) => {
-    if (index >= args.length)
-        return Number.NaN;
-    const arg = args[index];
-    if (typeof arg !== "number")
-        throw typeError(`Math.${name} expects number arguments.`);
-    return arg;
-};
-const unary = (name, op) => [name, 1, (_, args) => op(number(name, args, 0))];
+const unary = (name, op) => [name, 1, (_, args) => op(coerceToNumber(args[0]))];
 const binary = (name, op) => [
     name,
     2,
-    (_, args) => op(number(name, args, 0), number(name, args, 1)),
+    (_, args) => op(coerceToNumber(args[0]), coerceToNumber(args[1])),
 ];
 const variadic = (name, op) => [
     name,
     2,
-    (_, args) => op(...args.map((arg) => {
-        if (typeof arg !== "number")
-            throw typeError(`Math.${name} expects number arguments.`);
-        return arg;
-    })),
+    (_, args) => op(...args.map(coerceToNumber)),
 ];
 export const mathGlobal = (ctx) => {
     const builtins = ctx.builtins;
@@ -91,7 +79,7 @@ export const mathGlobal = (ctx) => {
                     const step = yield* cursor.next;
                     if (step.done)
                         return Math.sumPrecise(numbers);
-                    yield* preserveConsumerError(cursor, Effect.sync(() => {
+                    yield* preserveConsumerError(cursor.close, Effect.sync(() => {
                         if (typeof step.value !== "number") {
                             throw typeError("Math.sumPrecise expects an iterable of numbers.");
                         }

package/dist/stdlib/number.js

@@ -1,6 +1,7 @@
 import { constructor, constants, methods } from "../interpreter/native.js";
+import { coerceToNumber, coerceToString } from "../interpreter/objects.js";
 import { rangeError, typeError } from "../interpreter/model.js";
-import { coercion, coerceToString } from "./value.js";
+import { coercion } from "./value.js";
 export const numberGlobal = (ctx) => {
     const builtins = ctx.builtins;
     const number = constructor(builtins, builtins.Number, {
@@ -27,11 +28,7 @@ export const numberGlobal = (ctx) => {
             "parseInt",
             2,
             (_, args) => {
-                const radix = args[1];
-                if (radix !== undefined && typeof radix !== "number") {
-                    throw typeError("Number.parseInt expects a numeric radix.");
-                }
-                return parseInt(coerceToString(args[0]), radix);
+                return parseInt(coerceToString(args[0]), coerceToNumber(args[1]));
             },
         ],
         ["parseFloat", 1, (_, args) => parseFloat(coerceToString(args[0]))],
@@ -41,26 +38,17 @@ export const numberGlobal = (ctx) => {
             return thisValue;
         throw typeError(`Number.prototype.${name} requires that 'this' be a Number.`);
     };
-    const optNum = (name, arg) => {
-        if (arg === undefined)
-            return undefined;
-        if (typeof arg !== "number")
-            throw typeError(`Number.${name} expects a number argument.`);
-        return arg;
-    };
+    const optNum = (arg) => (arg === undefined ? undefined : coerceToNumber(arg));
     methods(builtins, builtins.Number, [
-        ["toFixed", 1, (thisValue, args) => self(thisValue, "toFixed").toFixed(optNum("toFixed", args[0]))],
-        [
-            "toExponential",
-            1,
-            (thisValue, args) => self(thisValue, "toExponential").toExponential(optNum("toExponential", args[0])),
-        ],
+        ["toFixed", 1, (thisValue, args) => self(thisValue, "toFixed").toFixed(optNum(args[0]))],
+        ["toLocaleString", 0, (thisValue) => self(thisValue, "toLocaleString").toLocaleString("en-US")],
+        ["toExponential", 1, (thisValue, args) => self(thisValue, "toExponential").toExponential(optNum(args[0]))],
         [
             "toPrecision",
             1,
             (thisValue, args) => {
                 const value = self(thisValue, "toPrecision");
-                const digits = optNum("toPrecision", args[0]);
+                const digits = optNum(args[0]);
                 return digits === undefined ? value.toString() : value.toPrecision(digits);
             },
         ],
@@ -69,7 +57,7 @@ export const numberGlobal = (ctx) => {
             1,
             (thisValue, args) => {
                 const value = self(thisValue, "toString");
-                const radix = optNum("toString", args[0]);
+                const radix = optNum(args[0]);
                 if (radix !== undefined && (radix < 2 || radix > 36)) {
                     throw rangeError("Number.toString radix must be between 2 and 36.");
                 }

package/dist/stdlib/object.d.ts

@@ -1,7 +1,6 @@
 import { type AstNode } from "../interpreter/model.js";
-import { Obj } from "../interpreter/objects.js";
+import { Obj, type Value } from "../interpreter/objects.js";
 import type { Interpreter } from "../interpreter/interpreter.js";
-export declare const enumerableSource: <R>(ctx: Interpreter<R>, label: string, value: unknown, node?: AstNode) => Obj;
-export declare const objectAssign: <R>(ctx: Interpreter<R>, args: Array<unknown>) => unknown;
-export declare const classTag: (value: unknown) => string;
+export declare const enumerableSource: <R>(ctx: Interpreter<R>, label: string, value: Value, node?: AstNode) => Obj;
+export declare const objectAssign: <R>(ctx: Interpreter<R>, args: Array<Value>) => Value;
 export declare const objectGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/object.js

@@ -1,12 +1,11 @@
 import { Effect } from "effect";
 import { constructor, methods, receiver } from "../interpreter/native.js";
 import { AsyncIteratorSymbol, invalidData, IteratorSymbol, rangeError, typeError, } from "../interpreter/model.js";
-import { Callable, define, entries, enumerableKeys, getOwn, hasOwn, hasPrototype, hidden, keys, own, Arr, Bytes, DateObj, ErrorObj, Obj, PromiseObj, RegExpObj, set, } from "../interpreter/objects.js";
+import { define, entries, enumerableKeys, getOwn, hasOwn, hasPrototype, hidden, keys, own, Arr, Obj, PromiseObj, set, coerceToString, } from "../interpreter/objects.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion } from "../interpreter/references.js";
-import { preserveConsumerError } from "../interpreter/callback.js";
+import { invoke, preserveConsumerError } from "../interpreter/callback.js";
 import { ToolReference } from "../tool-runtime.js";
 import { groupBy } from "./collections.js";
-import { coerceToString } from "./value.js";
 // ToObject for enumeration.
 export const enumerableSource = (ctx, label, value, node) => {
     if (value === null || value === undefined) {
@@ -57,7 +56,7 @@ const objectFromEntries = (ctx, source) => {
             const step = yield* cursor.next;
             if (step.done)
                 return out;
-            yield* preserveConsumerError(cursor, Effect.sync(() => {
+            yield* preserveConsumerError(cursor.close, Effect.sync(() => {
                 if (!(step.value instanceof Obj) || containsOpaqueReference(step.value)) {
                     throw typeError("Object.fromEntries expects [key, value] entry objects.");
                 }
@@ -66,23 +65,13 @@ const objectFromEntries = (ctx, source) => {
         }
     });
 };
-export const classTag = (value) => {
+const classTag = (value) => {
     if (value === null)
         return "Null";
     if (value === undefined)
         return "Undefined";
-    if (value instanceof Arr)
-        return "Array";
-    if (value instanceof Callable)
-        return "Function";
-    if (value instanceof ErrorObj)
-        return "Error";
-    if (value instanceof DateObj)
-        return "Date";
-    if (value instanceof RegExpObj)
-        return "RegExp";
-    if (value instanceof Bytes)
-        return "Uint8Array";
+    if (value instanceof Obj)
+        return value.tag;
     if (typeof value === "string")
         return "String";
     if (typeof value === "number")
@@ -161,7 +150,7 @@ export const objectGlobal = (ctx) => {
                 true,
         ],
         ["toString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
-        ["toLocaleString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
+        ["toLocaleString", 0, (thisValue) => invoke(ctx, thisValue, "toString", "Object.prototype.toLocaleString")],
         [
             "valueOf",
             0,

package/dist/stdlib/regexp.d.ts

@@ -1,7 +1,7 @@
 import type { Builtins } from "../interpreter/intrinsics.js";
-import { Arr, Obj, RegExpObj } from "../interpreter/objects.js";
+import { Arr, Obj, RegExpObj, type Value } from "../interpreter/objects.js";
 import type { Interpreter } from "../interpreter/interpreter.js";
-export declare const toHostRegex: (arg: unknown, method: string, extraFlags?: string) => RegExp;
+export declare const toHostRegex: (arg: Value, method: string, extraFlags?: string) => RegExp;
 export declare const matchToValue: (builtins: Builtins, match: RegExpMatchArray) => Arr;
-export declare const constructRegExp: (builtins: Builtins, args: Array<unknown>, proto?: Obj) => RegExpObj;
+export declare const constructRegExp: (builtins: Builtins, args: Array<Value>, proto?: Obj) => RegExpObj;
 export declare const regexpGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/regexp.js

@@ -1,8 +1,7 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
 import { syntaxError, typeError } from "../interpreter/model.js";
-import { define, defineAccessor, Arr, Obj, RegExpObj, record } from "../interpreter/objects.js";
-import { coerceToNumber, coerceToString } from "./value.js";
+import { define, defineAccessor, Arr, Obj, RegExpObj, record, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 const flagProperties = [
     "hasIndices",
     "global",

package/dist/stdlib/string.js

@@ -2,11 +2,11 @@ import { Effect } from "effect";
 import { constructor, fn, methods } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
-import { define, hidden, Arr, IteratorObj, PromiseObj, RegExpObj, record } from "../interpreter/objects.js";
+import { define, hidden, Arr, hostIterator, RegExpObj, record, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
 import { applyCollectionCallback, isSupportedCallback } from "../interpreter/callback.js";
 import { matchToValue, toHostRegex } from "./regexp.js";
-import { coerceToNumber, coerceToString, coercion } from "./value.js";
+import { coercion } from "./value.js";
 // console is intercepted by the interpreter before reaching here.
 const requireDataArgument = (name, index, arg) => {
     if (containsOpaqueReference(arg)) {
@@ -23,17 +23,16 @@ const replaceWithCallback = (ctx, value, name, args) => {
     const builtins = ctx.builtins;
     const apply = applyCollectionCallback(ctx, args[1], `String.${name}`);
     const matches = [];
+    // The host calls back with (match, ...captures, offset, string, groups?); only groups is not already a Value.
     const collect = (...callbackArgs) => {
         const match = callbackArgs[0];
-        const groups = callbackArgs[callbackArgs.length - 1];
-        const hasGroups = groups !== null && typeof groups === "object";
+        const hasGroups = typeof callbackArgs.at(-1) === "object";
         const offset = callbackArgs[callbackArgs.length - (hasGroups ? 3 : 2)];
         if (typeof match !== "string" || typeof offset !== "number") {
             throw typeError(`String.${name} produced an invalid replacement match.`);
         }
-        if (hasGroups)
-            callbackArgs[callbackArgs.length - 1] = record(builtins.Object, groups);
-        matches.push({ match, offset, args: callbackArgs });
+        const args = callbackArgs.map((arg) => (typeof arg === "object" ? record(builtins.Object, arg) : arg));
+        matches.push({ match, offset, args });
         return match;
     };
     const pattern = args[0];
@@ -57,7 +56,7 @@ const replaceWithCallback = (ctx, value, name, args) => {
         let end = 0;
         for (const match of matches) {
             const replacement = yield* apply(match.args);
-            output.push(value.slice(end, match.offset), replacement instanceof PromiseObj ? "[object Promise]" : coerceToString(replacement));
+            output.push(value.slice(end, match.offset), coerceToString(replacement));
             end = match.offset + match.match.length;
         }
         output.push(value.slice(end));
@@ -74,12 +73,7 @@ export const stringGlobal = (ctx) => {
     const codeUnits = (name, op) => [
         name,
         1,
-        (_, args) => op(...args.map((arg) => {
-            if (typeof arg !== "number") {
-                throw typeError(`String.${name} expects number arguments.`);
-            }
-            return arg;
-        })),
+        (_, args) => op(...args.map(coerceToNumber)),
     ];
     methods(builtins, string, [
         codeUnits("fromCharCode", String.fromCharCode),
@@ -103,11 +97,7 @@ export const stringGlobal = (ctx) => {
             throw typeError(`String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`);
         }
     };
-    const simple = (name, length, op) => [
-        name,
-        length,
-        (thisValue, args) => op(self(thisValue, name), args),
-    ];
+    const simple = (name, length, op) => [name, length, (thisValue, args) => op(self(thisValue, name), args)];
     const replace = (name) => simple(name, 2, (value, args) => {
         if (isSupportedCallback(args[1]))
             return replaceWithCallback(ctx, value, name, args);
@@ -130,6 +120,8 @@ export const stringGlobal = (ctx) => {
         simple("valueOf", 0, (value) => value),
         simple("toLowerCase", 0, (value) => value.toLowerCase()),
         simple("toUpperCase", 0, (value) => value.toUpperCase()),
+        simple("toLocaleLowerCase", 0, (value) => value.toLowerCase()),
+        simple("toLocaleUpperCase", 0, (value) => value.toUpperCase()),
         simple("trim", 0, (value) => value.trim()),
         simple("trimStart", 0, (value) => value.trimStart()),
         simple("trimLeft", 0, (value) => value.trimStart()),
@@ -232,6 +224,6 @@ export const stringGlobal = (ctx) => {
             return joined;
         }),
     ]);
-    define(builtins.String, IteratorSymbol, fn(builtins, "[Symbol.iterator]", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "[Symbol.iterator]")[Symbol.iterator]())), hidden);
+    define(builtins.String, IteratorSymbol, fn(builtins, "[Symbol.iterator]", 0, (thisValue) => hostIterator(builtins, self(thisValue, "[Symbol.iterator]")[Symbol.iterator]())), hidden);
     return string;
 };

package/dist/stdlib/url.d.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import { type Value } from "../interpreter/objects.js";
 import type { Interpreter } from "../interpreter/interpreter.js";
 type UriFunction = "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
 export declare const uriGlobal: <R>(ctx: Interpreter<R>, name: UriFunction) => import("../interpreter/objects.js").Native<R>;
@@ -7,6 +8,6 @@ export declare const urlGlobal: <R>(ctx: Interpreter<R>) => import("../interpret
  * Reads a synchronous iterable of `[name, value]` pairs as strings; `undefined` when `init` is not iterable. As in
  * WebIDL, the whole sequence is converted before any pair's length is checked.
  */
-export declare const readPairs: <R>(ctx: Interpreter<R>, init: unknown, label: string) => Effect.Effect<Array<[string, string]> | undefined, unknown, R>;
+export declare const readPairs: <R>(ctx: Interpreter<R>, init: Value, label: string) => Effect.Effect<Array<[string, string]> | undefined, unknown, R>;
 export declare const urlSearchParamsGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
 export {};

package/dist/stdlib/url.js

@@ -1,10 +1,8 @@
 import { Effect } from "effect";
 import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { IteratorSymbol, PendingThrow, typeError, uriError } from "../interpreter/model.js";
-import { define, defineAccessor, entries, get, hidden, isWrapper, Arr, IteratorObj, Obj, URLObj, URLSearchParamsObj, } from "../interpreter/objects.js";
-import { isRuntimeReference } from "../interpreter/references.js";
+import { define, defineAccessor, entries, get, hidden, Arr, hostIterator, Obj, URLObj, URLSearchParamsObj, coerceToString, isRuntimeReference, } from "../interpreter/objects.js";
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js";
-import { coerceToString } from "./value.js";
 const urlProperties = [
     "href",
     "origin",
@@ -107,7 +105,7 @@ const readPair = (ctx, value, label) => Effect.gen(function* () {
         const step = yield* cursor.next;
         if (step.done)
             return items;
-        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => coerceToString(step.value))));
+        items.push(yield* preserveConsumerError(cursor.close, Effect.sync(() => coerceToString(step.value))));
     }
 });
 /**
@@ -126,7 +124,7 @@ export const readPairs = (ctx, init, label) => Effect.gen(function* () {
                 throw typeError(`${label} expects iterable [name, value] pairs.`);
             return pairs;
         }
-        pairs.push(yield* preserveConsumerError(cursor, readPair(ctx, step.value, label)));
+        pairs.push(yield* preserveConsumerError(cursor.close, readPair(ctx, step.value, label)));
     }
 });
 const constructURLSearchParams = (ctx, init, proto) => {
@@ -147,8 +145,6 @@ const constructURLSearchParams = (ctx, init, proto) => {
         if (isRuntimeReference(init)) {
             throw typeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.");
         }
-        if (isWrapper(init))
-            return wrap(new URLSearchParams());
         if (!(init instanceof Obj)) {
             throw typeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.");
         }
@@ -237,15 +233,9 @@ export const urlSearchParamsGlobal = (ctx) => {
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").params.keys())],
-        ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").params.values())],
-        [
-            "entries",
-            0,
-            (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries")
-                .params.entries()
-                .map(([key, value]) => wrap([key, value]))),
-        ],
+        ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").params.keys())],
+        ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").params.values())],
+        ["entries", 0, (thisValue) => hostIterator(builtins, self(thisValue, "entries").iterator(builtins))],
         ["toString", 0, (thisValue) => self(thisValue, "toString").params.toString()],
         [
             "forEach",

package/dist/stdlib/value.d.ts

@@ -1,9 +1,6 @@
 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>(ctx: Interpreter<R>, name: Coercion, length?: number) => Native<R>;

package/dist/stdlib/value.js

@@ -1,59 +1,6 @@
 import { fn } from "../interpreter/native.js";
-import { typeError } from "../interpreter/model.js";
-import { get, isWrapper, Arr, Bytes, DateObj, ErrorObj, MapObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, HeadersObj, } from "../interpreter/objects.js";
+import { coerceToNumber, coerceToString } 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) => {
-    if (value === null)
-        return "null";
-    if (value === undefined)
-        return "undefined";
-    if (value instanceof DateObj)
-        return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date";
-    if (value instanceof RegExpObj)
-        return `/${value.regex.source}/${value.regex.flags}`;
-    if (value instanceof MapObj)
-        return "[object Map]";
-    if (value instanceof SetObj)
-        return "[object Set]";
-    if (value instanceof URLObj)
-        return value.url.href;
-    if (value instanceof URLSearchParamsObj)
-        return value.params.toString();
-    if (value instanceof HeadersObj)
-        return "[object Headers]";
-    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");
-        const shownName = typeof name === "string" ? name : "Error";
-        const shownMessage = typeof message === "string" ? message : "";
-        if (shownMessage === "")
-            return shownName;
-        if (shownName === "")
-            return shownMessage;
-        return `${shownName}: ${shownMessage}`;
-    }
-    if (value instanceof Arr) {
-        return value.items.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",");
-    }
-    if (typeof value === "object")
-        return "[object Object]";
-    return String(value);
-};
-export const coerceToNumber = (value) => {
-    if (value instanceof DateObj)
-        return value.time;
-    if (value instanceof Bytes)
-        return Number(coerceToString(value));
-    if (isWrapper(value))
-        return Number.NaN;
-    if (value instanceof Arr)
-        return Number(coerceToString(value));
-    return value !== null && typeof value === "object" ? Number.NaN : Number(value);
-};
 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.
@@ -64,21 +11,6 @@ const coerce = (ctx, name, args) => {
             return "";
     }
     const raw = args[0];
-    if (isWrapper(raw)) {
-        if (name === "Boolean")
-            return true;
-        if (name === "Number")
-            return coerceToNumber(raw);
-        if (name === "String")
-            return coerceToString(raw);
-        if (name === "isFinite")
-            return Number.isFinite(coerceToNumber(raw));
-        if (name === "isNaN")
-            return Number.isNaN(coerceToNumber(raw));
-        if (name === "parseInt")
-            return parseInt(coerceToString(raw));
-        return parseFloat(coerceToString(raw));
-    }
     if (name === "Number")
         return coerceToNumber(raw);
     if (name === "Boolean")
@@ -88,11 +20,7 @@ const coerce = (ctx, name, args) => {
     if (name === "isNaN")
         return Number.isNaN(coerceToNumber(raw));
     if (name === "parseInt") {
-        const radix = args[1];
-        if (radix !== undefined && typeof radix !== "number") {
-            throw typeError("parseInt expects a numeric radix.");
-        }
-        return parseInt(coerceToString(raw), radix);
+        return parseInt(coerceToString(raw), coerceToNumber(args[1]));
     }
     if (name === "parseFloat")
         return parseFloat(coerceToString(raw));

package/dist/stdlib/web.js

@@ -1,8 +1,7 @@
 import { fn, methods } from "../interpreter/native.js";
 import { typeError } from "../interpreter/model.js";
-import { Bytes, Obj } from "../interpreter/objects.js";
+import { Bytes, Obj, coerceToString } 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 = (ctx, name) => fn(ctx.builtins, name, 1, (_, args) => {

package/dist/tool-runtime.d.ts

@@ -66,6 +66,8 @@ export type Prepared<R = never> = {
 };
 export type SearchEntry = {
     readonly description: ToolDescription;
+    /** The path split into words, so `zones` matches `get_zones` as a word rather than as a substring of `timezones`. */
+    readonly pathWords: ReadonlyArray<string>;
     readonly searchText: string;
 };
 /** Exact callable signature of the built-in `search` function, for host-owned instructions. */

package/dist/tool-runtime.js

@@ -90,7 +90,7 @@ const describeTool = (visible) => {
             // Joining the final fragments avoids retaining the rendering's intermediate string ropes in JSC.
             return (signature ??= [
                 toolExpression(visible.path),
-                isEmptyInput(visible.tool) ? "()" : `(input: ${inputTypeScript(visible.tool, true)})`,
+                isEmptyInput(visible.tool) ? "()" : `(${inputTypeScript(visible.tool, true)})`,
                 `: Promise<${outputTypeScript(visible.tool, true)}>`,
             ].join(""));
         },
@@ -109,6 +109,24 @@ const termForms = (term) => {
         forms.push(term.slice(0, -1));
     return forms;
 };
+const rank = (entries, query) => {
+    const terms = tokenize(query).map(termForms);
+    return entries
+        .map((entry) => {
+        const path = entry.description.path.toLowerCase();
+        const description = entry.description.description.toLowerCase();
+        const score = terms.reduce((total, forms) => total +
+            (forms.some((form) => path === form || path.endsWith(`.${form}`)) ? 20 : 0) +
+            (forms.some((form) => entry.pathWords.includes(form)) ? 12 : 0) +
+            (forms.some((form) => path.includes(form)) ? 8 : 0) +
+            (forms.some((form) => description.includes(form)) ? 4 : 0) +
+            (forms.some((form) => entry.searchText.includes(form)) ? 2 : 0), 0);
+        return { entry, score };
+    })
+        .filter(({ score }) => terms.length === 0 || score > 0)
+        .sort((left, right) => right.score - left.score || compareText(left.entry.description.path, right.entry.description.path))
+        .map(({ entry }) => entry);
+};
 const makeSearchTool = (searchIndex) => ({
     _tag: "CodeModeTool",
     description: "Search available tools",
@@ -118,32 +136,22 @@ const makeSearchTool = (searchIndex) => ({
         const request = input;
         const query = request.query ?? "";
         const offset = request.offset ?? 0;
-        const scoped = request.namespace === undefined
+        let ns = request.namespace;
+        if (ns !== undefined && !searchIndex.some((entry) => entry.description.path.startsWith("tools."))) {
+            if (ns === "tools")
+                ns = undefined;
+            else if (ns.startsWith("tools."))
+                ns = ns.slice("tools.".length);
+        }
+        const scoped = ns === undefined
             ? searchIndex
-            : searchIndex.filter((entry) => entry.description.path === request.namespace ||
-                entry.description.path.startsWith(`${request.namespace}.`));
+            : searchIndex.filter((entry) => entry.description.path === ns || entry.description.path.startsWith(`${ns}.`));
         const trimmed = query.trim();
         const pathQuery = trimmed.startsWith("tools.") ? trimmed.slice("tools.".length) : trimmed;
         const exact = pathQuery === ""
             ? undefined
             : scoped.find((entry) => entry.description.path === pathQuery || toolExpression(entry.description.path) === trimmed);
-        const terms = tokenize(query).map(termForms);
-        const ranked = exact !== undefined
-            ? [exact]
-            : scoped
-                .map((entry) => {
-                const path = entry.description.path.toLowerCase();
-                const description = entry.description.description.toLowerCase();
-                const score = terms.reduce((total, forms) => total +
-                    (forms.some((form) => path === form || path.endsWith(`.${form}`)) ? 20 : 0) +
-                    (forms.some((form) => path.includes(form)) ? 8 : 0) +
-                    (forms.some((form) => description.includes(form)) ? 4 : 0) +
-                    (forms.some((form) => entry.searchText.includes(form)) ? 2 : 0), 0);
-                return { entry, score };
-            })
-                .filter(({ score }) => terms.length === 0 || score > 0)
-                .sort((left, right) => right.score - left.score || compareText(left.entry.description.path, right.entry.description.path))
-                .map(({ entry }) => entry);
+        const ranked = exact !== undefined ? [exact] : rank(scoped, query);
         const items = ranked.slice(offset, offset + (request.limit ?? defaultSearchLimit)).map(({ description }) => ({
             ...description,
             path: toolExpression(description.path),
@@ -159,10 +167,11 @@ const makeSearchTool = (searchIndex) => ({
 /** Exact callable signature of the built-in `search` function, for host-owned instructions. */
 export const searchSignature = (() => {
     const tool = makeSearchTool([]);
-    return `search(input: ${inputTypeScript(tool, true)}): ${outputTypeScript(tool, true)}`;
+    return `search(${inputTypeScript(tool, true)}): ${outputTypeScript(tool, true)}`;
 })();
 const toSearchEntry = (visible) => ({
     description: describeTool(visible),
+    pathWords: tokenize(visible.path),
     searchText: [
         visible.path,
         visible.tool.description,
@@ -199,13 +208,16 @@ const namespaceKeys = (root, path) => {
     }
     return Array.from(node.children.keys());
 };
-const resolve = (root, path) => {
+const resolve = (root, path, index) => {
     const segments = canonicalSegments(path);
     const node = lookup(root, segments);
     if (node === undefined) {
-        throw new ToolRuntimeError("UnknownTool", `Unknown tool '${segments.join(".")}'.`, [
-            "The tool may have been removed or renamed. Use search to find available tools.",
-        ]);
+        const name = segments.join(".");
+        const ns = segments.length > 1 && root.children.has(segments[0]) ? segments[0] : undefined;
+        const closest = rank(ns ? index.filter((entry) => entry.description.path.startsWith(`${ns}.`)) : index, ns ? segments.slice(1).join(" ") : name)[0];
+        throw new ToolRuntimeError("UnknownTool", closest
+            ? `Unknown tool '${name}'. Did you mean ${toolExpression(closest.description.path)}?`
+            : `Unknown tool '${name}'.`, ["Use search to find available tools."]);
     }
     if (node.tool === undefined) {
         throw new ToolRuntimeError("UnknownTool", `Tool '${segments.join(".")}' is not callable.`);
@@ -269,7 +281,7 @@ export const make = (prepared, maxToolCalls, hooks = {}) => {
             // Models often write `tools.search(...)` for the bare `search(...)`; honor it unless a tool owns that path.
             if (segments.length === 1 && segments[0] === "search" && lookup(root, segments) === undefined)
                 return executeTool("search", makeSearchTool(prepared.searchIndex), args);
-            return executeTool(segments.join("."), resolve(root, path), args);
+            return executeTool(segments.join("."), resolve(root, path, prepared.searchIndex), args);
         }),
     };
 };