@opencode/codemode 2.0.11 → 2.0.12

package/dist/interpreter/callback.d.ts

@@ -14,6 +14,8 @@ export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, ef
  * default hint as "string", like their `Symbol.toPrimitive`.
  */
 export declare const toPrimitive: <R>(ctx: Interpreter<R>, value: unknown, hint: "number" | "string" | "default") => Effect.Effect<unknown, unknown, R>;
+/** Invoke(value, name): calls the method the value would find through its prototype. */
+export declare const invoke: <R>(ctx: Interpreter<R>, value: unknown, name: string, label: string) => Effect.Effect<unknown, unknown, R>;
 export declare const toPrimitiveString: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<string, unknown, R>;
 export declare const toPrimitiveNumber: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<number, unknown, R>;
 export declare const isSupportedCallback: (value: unknown) => value is Callable;

package/dist/interpreter/callback.js

@@ -1,5 +1,6 @@
 import { Effect, Exit } from "effect";
 import { coerceToNumber, coerceToString } from "../stdlib/value.js";
+import { primitivePrototype } from "./intrinsics.js";
 import { typeError } from "./model.js";
 import { Callable, get, Native, DateObj, Obj } from "./objects.js";
 import { typeofValue } from "./references.js";
@@ -27,6 +28,13 @@ export const toPrimitive = (ctx, value, hint) => {
         throw typeError("Cannot convert object to primitive value.");
     });
 };
+/** Invoke(value, name): calls the method the value would find through its prototype. */
+export const invoke = (ctx, value, name, label) => {
+    const target = value instanceof Obj ? value : primitivePrototype(ctx.builtins, value);
+    if (target === undefined)
+        throw typeError(`${label} called on null or undefined.`);
+    return ctx.call(get(target, name), value, []);
+};
 export const toPrimitiveString = (ctx, value) => Effect.map(toPrimitive(ctx, value, "string"), coerceToString);
 export const toPrimitiveNumber = (ctx, value) => Effect.map(toPrimitive(ctx, value, "number"), coerceToNumber);
 // The single acceptance list for callbacks: collections, sort, string replacers,

package/dist/interpreter/errors.js

@@ -150,6 +150,7 @@ export const errorGlobal = (type, ctx) => {
         methods(builtins, prototype, [
             ["toString", 0, (thisValue) => errorToString(receiver(Obj, thisValue, "Error.prototype.toString"))],
         ]);
+        methods(builtins, ctor, [["isError", 1, (_, args) => args[0] instanceof ErrorObj]]);
     }
     return ctor;
 };

package/dist/interpreter/interpreter.d.ts

@@ -2,7 +2,7 @@ import type { Program } from "acorn";
 import { Effect } from "effect";
 import { type Json } from "../data.js";
 import { type ToolRuntime } from "../tool-runtime.js";
-import type { Builtins } from "./intrinsics.js";
+import { type Builtins } from "./intrinsics.js";
 import { PromiseObj } from "./objects.js";
 import { Pending } from "./promises.js";
 /** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */

package/dist/interpreter/interpreter.js

@@ -4,6 +4,7 @@ import { ToolReference } from "../tool-runtime.js";
 import { AsyncIteratorSymbol, CallSite, GeneratorReturn, IteratorSymbol, OptionalShortCircuit, invalidData, Throw, rangeError, typeError, unsupportedSyntax, } from "./model.js";
 import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
+import { primitivePrototype } from "./intrinsics.js";
 import { globals } from "./globals.js";
 import { assign, Callable, define, get, has, hasPrototype, keys, Native, parseArrayIndex, Arr, Bytes, DateObj, Fn, GeneratorObj, IteratorObj, MapObj, Obj, PromiseObj, SetObj, URLSearchParamsObj, HeadersObj, record, remove, set, } from "./objects.js";
 import { preserveConsumerError } from "./callback.js";
@@ -27,21 +28,27 @@ const loopExit = (result, labels) => {
         return result;
     return undefined;
 };
-const calleeDescription = (callee) => {
-    if (callee?.type === "Identifier")
-        return callee.name;
-    if (callee?.type === "MemberExpression") {
-        const object = callee.object;
-        const property = callee.property;
-        const key = !callee.computed && property.type === "Identifier"
-            ? property.name
-            : property.type === "Literal" && typeof property.value === "string"
-                ? property.value
-                : undefined;
-        if (object.type === "Identifier" && key !== undefined)
-            return `${object.name}.${key}`;
-    }
-    return "The called value";
+// Native engines name the callee (`search(...).catch is not a function`), including call chains. Returns
+// undefined when a link cannot be named, so a chain is either named completely or not at all.
+const calleeDescription = (node) => {
+    if (node?.type === "Identifier")
+        return node.name;
+    if (node?.type === "CallExpression") {
+        const target = calleeDescription(node.callee);
+        return target === undefined ? undefined : `${target}(...)`;
+    }
+    if (node?.type !== "MemberExpression")
+        return undefined;
+    const property = node.property;
+    const key = !node.computed && property.type === "Identifier"
+        ? property.name
+        : property.type === "Literal" && typeof property.value === "string"
+            ? property.value
+            : undefined;
+    if (key === undefined)
+        return undefined;
+    const object = calleeDescription(node.object);
+    return object === undefined ? undefined : `${object}.${key}`;
 };
 // OrdinaryHasInstance: walk the left operand's chain looking for the constructor's `prototype`.
 const instanceofValue = (lhs, rhs, node) => {
@@ -1025,7 +1032,7 @@ class Frame {
                 // `new` itself is supported, so a non-constructible callee is a TypeError like JS rather than
                 // unsupported syntax. Built-ins like Number are real constructors in JS, so do not claim
                 // otherwise; say `new` is unsupported for them and point at the plain call.
-                const name = calleeDescription(node.callee);
+                const name = calleeDescription(node.callee) ?? "The called value";
                 const message = callee instanceof Fn
                     ? `${name} cannot be constructed: user-defined constructors and classes are not supported. Call it as a function that returns a plain object instead.`
                     : callee instanceof Native
@@ -1312,7 +1319,7 @@ class Frame {
             if (callable instanceof Native) {
                 return yield* self.native(() => callable.call(thisValue, args), node);
             }
-            throw typeError(`${calleeDescription(callee)} is not a function.`, callee ?? node);
+            throw typeError(`${calleeDescription(callee) ?? "The called value"} is not a function.`, callee ?? node);
         });
     }
     // Built-ins throw without a location, synchronously or inside their Effect; the call site supplies it.
@@ -1712,20 +1719,17 @@ class Frame {
             }
             if (objectValue instanceof Obj)
                 return { target: objectValue, key, receiver: objectValue };
-            // Primitives read through their wrapper prototype without being boxed; strings own length and indexes.
-            const builtins = self.ctx.builtins;
+            // Strings own length and indexes; every other primitive property reads through the wrapper prototype.
             if (typeof objectValue === "string") {
                 if (key === "length")
                     return { value: objectValue.length };
                 const index = typeof key === "symbol" ? undefined : parseArrayIndex(key);
                 if (index !== undefined)
                     return { value: objectValue[index] };
-                return { target: builtins.String, key, receiver: objectValue };
             }
-            if (typeof objectValue === "number")
-                return { target: builtins.Number, key, receiver: objectValue };
-            if (typeof objectValue === "boolean")
-                return { target: builtins.Boolean, key, receiver: objectValue };
+            const proto = primitivePrototype(self.ctx.builtins, objectValue);
+            if (proto !== undefined)
+                return { target: proto, key, receiver: objectValue };
             if (objectValue === null || objectValue === undefined) {
                 throw typeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode);
             }

package/dist/interpreter/intrinsics.d.ts

@@ -9,5 +9,7 @@ declare const builtins: readonly ["Object", "Function", "Array", "String", "Numb
  */
 export type Builtins = Readonly<Record<(typeof builtins)[number] | ErrorType, Obj>>;
 export declare const createErrorValue: (prototype: Obj, message: string | undefined) => ErrorObj;
+/** The prototype a primitive reads its methods from without being boxed; none for null, undefined, and symbols. */
+export declare const primitivePrototype: (builtins: Builtins, value: unknown) => Obj | undefined;
 export declare const createBuiltins: () => Builtins;
 export {};

package/dist/interpreter/intrinsics.js

@@ -40,6 +40,16 @@ export const createErrorValue = (prototype, message) => {
         define(value, "message", message, hidden);
     return value;
 };
+/** The prototype a primitive reads its methods from without being boxed; none for null, undefined, and symbols. */
+export const primitivePrototype = (builtins, value) => {
+    if (typeof value === "string")
+        return builtins.String;
+    if (typeof value === "number")
+        return builtins.Number;
+    if (typeof value === "boolean")
+        return builtins.Boolean;
+    return undefined;
+};
 export const createBuiltins = () => {
     const object = new Obj(null);
     // Function.prototype is itself callable and returns undefined.

package/dist/interpreter/model.js

@@ -52,9 +52,10 @@ export const uriError = failure("URIError");
 export const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
 export const unsupportedSyntax = (kind, node) => new PendingThrow("SyntaxError", `Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
 export const isRecord = (value) => typeof value === "object" && value !== null;
+// Acorn lines are 1-based and its columns are 0-based. Diagnostics use 1-based columns of the submitted source.
 export const sourceLocation = (node) => ({
-    line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
-    column: Math.max(1, (node.loc?.start.column ?? 4) - 3),
+    line: node.loc?.start.line ?? 1,
+    column: (node.loc?.start.column ?? 0) + 1,
 });
 export const formatLocation = (node) => {
     if (!node?.loc)

package/dist/stdlib/array.js

@@ -4,7 +4,7 @@ import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interp
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
 import { define, get, hidden, Arr, GeneratorObj, IteratorObj, Obj } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
-import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js";
+import { applyCollectionCallback, invoke, preserveConsumerError } from "../interpreter/callback.js";
 import { compareText } from "../tool-runtime.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 const arrayLikeSource = (source) => {
@@ -317,6 +317,13 @@ export const arrayGlobal = (ctx) => {
                 return target;
             },
         ],
+        [
+            "toLocaleString",
+            0,
+            (thisValue) => Effect.map(Effect.forEach(self(thisValue, "toLocaleString").items, (item) => item === null || item === undefined
+                ? Effect.succeed("")
+                : Effect.map(invoke(ctx, item, "toLocaleString", "Array.prototype.toLocaleString"), coerceToString)), (parts) => parts.join(",")),
+        ],
         ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").items.keys())],
         ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").items.values())],
         [

package/dist/stdlib/collections.js

@@ -123,6 +123,31 @@ export const mapGlobal = (ctx) => {
                 return target;
             },
         ],
+        [
+            "getOrInsert",
+            2,
+            (thisValue, args) => {
+                const target = self(thisValue, "getOrInsert").map;
+                if (!target.has(args[0]))
+                    target.set(args[0], args[1]);
+                return target.get(args[0]);
+            },
+        ],
+        [
+            "getOrInsertComputed",
+            2,
+            (thisValue, args) => {
+                const target = self(thisValue, "getOrInsertComputed").map;
+                const apply = applyCollectionCallback(ctx, args[1], "Map.getOrInsertComputed");
+                if (target.has(args[0]))
+                    return target.get(args[0]);
+                // The callback sees the stored key (-0 is +0) and its result wins over anything it inserted itself.
+                return Effect.map(apply([args[0] === 0 ? 0 : args[0]]), (value) => {
+                    target.set(args[0], value);
+                    return value;
+                });
+            },
+        ],
         ["delete", 1, (thisValue, args) => self(thisValue, "delete").map.delete(args[0])],
         [
             "clear",

package/dist/stdlib/date.js

@@ -92,6 +92,11 @@ export const dateGlobal = (ctx) => {
         ["toTimeString", 0, (thisValue) => new Date(self(thisValue, "toTimeString").time).toTimeString()],
         ["toUTCString", 0, (thisValue) => new Date(self(thisValue, "toUTCString").time).toUTCString()],
         ["toGMTString", 0, (thisValue) => new Date(self(thisValue, "toGMTString").time).toUTCString()],
+        ...["toLocaleString", "toLocaleDateString", "toLocaleTimeString"].map((name) => [
+            name,
+            0,
+            (thisValue) => new Date(self(thisValue, name).time)[name]("en-US", { timeZone: "UTC" }),
+        ]),
         ...getters.map((name) => [name, 0, (thisValue) => new Date(self(thisValue, name).time)[name]()]),
         ...setters.map(([name, length]) => [
             name,

package/dist/stdlib/number.js

@@ -50,6 +50,7 @@ export const numberGlobal = (ctx) => {
     };
     methods(builtins, builtins.Number, [
         ["toFixed", 1, (thisValue, args) => self(thisValue, "toFixed").toFixed(optNum("toFixed", args[0]))],
+        ["toLocaleString", 0, (thisValue) => self(thisValue, "toLocaleString").toLocaleString("en-US")],
         [
             "toExponential",
             1,

package/dist/stdlib/object.js

@@ -3,7 +3,7 @@ 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 { 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";
@@ -161,7 +161,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/string.js

@@ -130,6 +130,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()),

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

@@ -136,6 +136,7 @@ const makeSearchTool = (searchIndex) => ({
                 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);
@@ -163,6 +164,7 @@ export const searchSignature = (() => {
 })();
 const toSearchEntry = (visible) => ({
     description: describeTool(visible),
+    pathWords: tokenize(visible.path),
     searchText: [
         visible.path,
         visible.tool.description,

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "2.0.11",
+  "version": "2.0.12",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",