@opencode/codemode 2.0.15 → 2.0.17

package/dist/stdlib/string.js

@@ -4,7 +4,7 @@ import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
 import { define, get, hidden, Arr, hostIterator, Obj, RegExpObj, record, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
-import { applyCollectionCallback, isSupportedCallback, toPrimitiveString } from "../interpreter/callback.js";
+import { applyCollectionCallback, isSupportedCallback, toPrimitiveString, withPrimitives, } from "../interpreter/callback.js";
 import { matchToValue, toHostRegex } from "./regexp.js";
 import { coercion } from "./value.js";
 // console is intercepted by the interpreter before reaching here.
@@ -111,28 +111,50 @@ export const stringGlobal = (ctx) => {
     const num = (name, args, index) => coerceToNumber(requireDataArgument(name, index, args[index]));
     const optNum = (name, args, index) => args[index] === undefined ? undefined : num(name, args, index);
     const optStr = (name, args, index) => args[index] === undefined ? undefined : str(name, args, index);
-    const rejectRegex = (name, args) => {
+    // ToPrimitive in spec order: the receiver, then the arguments the method consumes, one hint per position; the
+    // rest pass through as they are.
+    const simple = (name, length, op, hints = []) => [
+        name,
+        length,
+        (thisValue, args) => {
+            if (thisValue === null || thisValue === undefined) {
+                throw typeError(`String.prototype.${name} called on null or undefined.`);
+            }
+            return withPrimitives(ctx, ["string", ...hints], [thisValue, ...args.slice(0, hints.length)], ([value, ...primitives]) => op(coerceToString(value), [...primitives, ...args.slice(hints.length)]));
+        },
+    ];
+    // includes, startsWith, and endsWith reject a RegExp before converting their search string and position.
+    const searching = (name, op) => simple(name, 1, (value, args) => {
         if (args[0] instanceof RegExpObj) {
             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)];
+        return withPrimitives(ctx, ["string", "number"], args.slice(0, 2), (primitives) => op(value, str(name, primitives, 0), optNum(name, primitives, 1)));
+    });
+    // match, matchAll, and search read a RegExp as is and convert anything else to its pattern text.
+    const withPattern = (args, op) => args[0] instanceof RegExpObj ? op(args[0]) : withPrimitives(ctx, "string", [args[0]], ([text]) => op(text));
     const replace = (name) => simple(name, 2, (value, args) => {
-        if (isSupportedCallback(args[1]))
-            return replaceWithCallback(ctx, value, name, args);
-        if (typeofValue(args[1]) === "function") {
-            throw typeError(`String.${name} cannot use this callable as a replacer; wrap it in an arrow function, e.g. (match) => tools.ns.tool(match).`);
-        }
-        if (args[0] instanceof RegExpObj) {
-            const pattern = args[0].regex;
-            const replacement = str(name, args, 1);
-            if (name === "replaceAll")
-                replaceAllNeedsGlobal(pattern);
-            return name === "replace" ? value.replace(pattern, replacement) : value.replaceAll(pattern, replacement);
-        }
-        if (name === "replace")
-            return value.replace(str(name, args, 0), str(name, args, 1));
-        return value.replaceAll(str(name, args, 0), str(name, args, 1));
+        const pattern = args[0];
+        const replacer = args[1];
+        // A RegExp pattern is used as is; a plain one converts to its search string, then a non-callable replacement.
+        return withPrimitives(ctx, "string", [pattern instanceof RegExpObj ? undefined : pattern, isSupportedCallback(replacer) ? undefined : replacer], ([search, replacement]) => {
+            if (isSupportedCallback(replacer)) {
+                return replaceWithCallback(ctx, value, name, [pattern instanceof RegExpObj ? pattern : search, replacer]);
+            }
+            if (typeofValue(replacer) === "function") {
+                throw typeError(`String.${name} cannot use this callable as a replacer; wrap it in an arrow function, e.g. (match) => tools.ns.tool(match).`);
+            }
+            const primitives = [search, replacement];
+            if (pattern instanceof RegExpObj) {
+                const regex = pattern.regex;
+                const text = str(name, primitives, 1);
+                if (name === "replaceAll")
+                    replaceAllNeedsGlobal(regex);
+                return name === "replace" ? value.replace(regex, text) : value.replaceAll(regex, text);
+            }
+            if (name === "replace")
+                return value.replace(str(name, primitives, 0), str(name, primitives, 1));
+            return value.replaceAll(str(name, primitives, 0), str(name, primitives, 1));
+        });
     });
     methods(builtins, builtins.String, [
         simple("toString", 0, (value) => value),
@@ -147,7 +169,7 @@ export const stringGlobal = (ctx) => {
         simple("trimEnd", 0, (value) => value.trimEnd()),
         simple("trimRight", 0, (value) => value.trimEnd()),
         // Locale/options are deliberately unsupported; comparison uses the host default locale.
-        simple("localeCompare", 1, (value, args) => value.localeCompare(str("localeCompare", args, 0))),
+        simple("localeCompare", 1, (value, args) => value.localeCompare(str("localeCompare", args, 0)), ["string"]),
         simple("normalize", 0, (value, args) => {
             const form = optStr("normalize", args, 0);
             try {
@@ -156,61 +178,62 @@ export const stringGlobal = (ctx) => {
             catch {
                 throw rangeError(`String.normalize expects the form "NFC", "NFD", "NFKC", or "NFKD" (got ${JSON.stringify(form)}).`);
             }
-        }),
+        }, ["string"]),
         simple("split", 2, (value, args) => {
-            const wrap = (parts) => new Arr(builtins.Array, parts);
-            // Native: an undefined separator returns the whole string, not a split on "undefined",
-            // unless the limit truncates to zero.
-            const requestedLimit = optNum("split", args, 1);
-            if (args[0] === undefined) {
-                return wrap(requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value]);
-            }
-            const parts = args[0] instanceof RegExpObj
-                ? value.split(args[0].regex, requestedLimit)
-                : value.split(str("split", args, 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0);
-            checkArrayLength(parts.length);
-            return wrap(parts);
-        }),
-        simple("slice", 2, (value, args) => value.slice(optNum("slice", args, 0), optNum("slice", args, 1))),
-        simple("includes", 1, (value, args) => {
-            rejectRegex("includes", args);
-            return value.includes(str("includes", args, 0), optNum("includes", args, 1));
+            const separator = args[0];
+            // A RegExp separator is used as is; the limit converts before a plain separator does, as in the spec.
+            return withPrimitives(ctx, ["number", "string"], [args[1], separator instanceof RegExpObj ? undefined : separator], ([limit, pattern]) => {
+                const wrap = (parts) => new Arr(builtins.Array, parts);
+                // Native: an undefined separator returns the whole string, not a split on "undefined",
+                // unless the limit truncates to zero.
+                const requestedLimit = args[1] === undefined ? undefined : num("split", [pattern, limit], 1);
+                if (separator === undefined) {
+                    return wrap(requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value]);
+                }
+                const parts = separator instanceof RegExpObj
+                    ? value.split(separator.regex, requestedLimit)
+                    : value.split(str("split", [pattern], 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0);
+                checkArrayLength(parts.length);
+                return wrap(parts);
+            });
         }),
-        simple("startsWith", 1, (value, args) => {
-            rejectRegex("startsWith", args);
-            return value.startsWith(str("startsWith", args, 0), optNum("startsWith", args, 1));
-        }),
-        simple("endsWith", 1, (value, args) => {
-            rejectRegex("endsWith", args);
-            return value.endsWith(str("endsWith", args, 0), optNum("endsWith", args, 1));
-        }),
-        simple("indexOf", 1, (value, args) => value.indexOf(str("indexOf", args, 0), optNum("indexOf", args, 1))),
-        simple("lastIndexOf", 1, (value, args) => value.lastIndexOf(str("lastIndexOf", args, 0), optNum("lastIndexOf", args, 1))),
+        simple("slice", 2, (value, args) => value.slice(optNum("slice", args, 0), optNum("slice", args, 1)), [
+            "number",
+            "number",
+        ]),
+        searching("includes", (value, search, position) => value.includes(search, position)),
+        searching("startsWith", (value, search, position) => value.startsWith(search, position)),
+        searching("endsWith", (value, search, position) => value.endsWith(search, position)),
+        simple("indexOf", 1, (value, args) => value.indexOf(str("indexOf", args, 0), optNum("indexOf", args, 1)), [
+            "string",
+            "number",
+        ]),
+        simple("lastIndexOf", 1, (value, args) => value.lastIndexOf(str("lastIndexOf", args, 0), optNum("lastIndexOf", args, 1)), ["string", "number"]),
         replace("replace"),
         replace("replaceAll"),
-        simple("match", 1, (value, args) => {
-            const pattern = toHostRegex(args[0], "match");
-            const matched = value.match(pattern);
+        simple("match", 1, (value, args) => withPattern(args, (arg) => {
+            const regex = toHostRegex(arg, "match");
+            const matched = value.match(regex);
             if (matched === null)
                 return null;
             // Preserve the own `index` and `groups` properties on non-global matches.
-            if (pattern.global)
+            if (regex.global)
                 return new Arr(builtins.Array, [...matched]);
             return matchToValue(builtins, matched);
-        }),
-        simple("matchAll", 1, (value, args) => {
-            const pattern = toHostRegex(args[0], "matchAll", "g");
-            if (!pattern.global) {
-                throw typeError(`String.matchAll requires a regular expression with the global (g) flag: write /${pattern.source}/${pattern.flags}g, or use String.match for a single match.`);
+        })),
+        simple("matchAll", 1, (value, args) => withPattern(args, (arg) => {
+            const regex = toHostRegex(arg, "matchAll", "g");
+            if (!regex.global) {
+                throw typeError(`String.matchAll requires a regular expression with the global (g) flag: write /${regex.source}/${regex.flags}g, or use String.match for a single match.`);
             }
             const matches = [];
-            for (const match of value.matchAll(pattern)) {
+            for (const match of value.matchAll(regex)) {
                 checkArrayLength(matches.length + 1);
                 matches.push(matchToValue(builtins, match));
             }
             return new Arr(builtins.Array, matches);
-        }),
-        simple("search", 1, (value, args) => value.search(toHostRegex(args[0], "search"))),
+        })),
+        simple("search", 1, (value, args) => withPattern(args, (arg) => value.search(toHostRegex(arg, "search")))),
         simple("repeat", 1, (value, args) => {
             const count = num("repeat", args, 0);
             if (!Number.isFinite(count) || count < 0) {
@@ -218,30 +241,33 @@ export const stringGlobal = (ctx) => {
             }
             checkStringLength(value.length * count);
             return value.repeat(count);
-        }),
+        }, ["number"]),
         simple("padStart", 1, (value, args) => {
             const length = num("padStart", args, 0);
             checkStringLength(length);
             return value.padStart(length, optStr("padStart", args, 1));
-        }),
+        }, ["number", "string"]),
         simple("padEnd", 1, (value, args) => {
             const length = num("padEnd", args, 0);
             checkStringLength(length);
             return value.padEnd(length, optStr("padEnd", args, 1));
-        }),
-        simple("charAt", 1, (value, args) => value.charAt(optNum("charAt", args, 0) ?? 0)),
-        simple("at", 1, (value, args) => value.at(optNum("at", args, 0) ?? 0)),
-        simple("substring", 2, (value, args) => value.substring(optNum("substring", args, 0) ?? 0, optNum("substring", args, 1))),
-        simple("substr", 2, (value, args) => value.substr(optNum("substr", args, 0) ?? 0, optNum("substr", args, 1))),
+        }, ["number", "string"]),
+        simple("charAt", 1, (value, args) => value.charAt(optNum("charAt", args, 0) ?? 0), ["number"]),
+        simple("at", 1, (value, args) => value.at(optNum("at", args, 0) ?? 0), ["number"]),
+        simple("substring", 2, (value, args) => value.substring(optNum("substring", args, 0) ?? 0, optNum("substring", args, 1)), ["number", "number"]),
+        simple("substr", 2, (value, args) => value.substr(optNum("substr", args, 0) ?? 0, optNum("substr", args, 1)), [
+            "number",
+            "number",
+        ]),
         simple("isWellFormed", 0, (value) => value.isWellFormed()),
         simple("toWellFormed", 0, (value) => value.toWellFormed()),
-        simple("charCodeAt", 1, (value, args) => value.charCodeAt(optNum("charCodeAt", args, 0) ?? 0)),
-        simple("codePointAt", 1, (value, args) => value.codePointAt(optNum("codePointAt", args, 0) ?? 0)),
-        simple("concat", 1, (value, args) => {
-            const joined = value.concat(...args.map((_, index) => str("concat", args, index)));
+        simple("charCodeAt", 1, (value, args) => value.charCodeAt(optNum("charCodeAt", args, 0) ?? 0), ["number"]),
+        simple("codePointAt", 1, (value, args) => value.codePointAt(optNum("codePointAt", args, 0) ?? 0), ["number"]),
+        simple("concat", 1, (value, args) => withPrimitives(ctx, "string", args, (parts) => {
+            const joined = value.concat(...parts.map((_, index) => str("concat", parts, index)));
             checkStringLength(joined.length);
             return joined;
-        }),
+        })),
     ]);
     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.js

@@ -246,7 +246,7 @@ export const urlSearchParamsGlobal = (ctx) => {
                 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]);
+                        yield* apply([value, key, target], args[1]);
                     return undefined;
                 });
             },

package/dist/stdlib/value.d.ts

@@ -1,6 +1,7 @@
-import { type Native } from "../interpreter/objects.js";
+import { type Native, type Value } from "../interpreter/objects.js";
 import type { Interpreter } from "../interpreter/interpreter.js";
 export declare const compoundOperators: Set<string>;
 export type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
+export declare const coerce: <R>(ctx: Interpreter<R>, name: Coercion, args: Array<Value>) => Value | import("effect/Effect").Effect<Value, unknown, R>;
 /** 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,7 +1,8 @@
 import { fn } from "../interpreter/native.js";
 import { coerceToNumber, coerceToString } from "../interpreter/objects.js";
+import { withPrimitives } from "../interpreter/callback.js";
 export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="]);
-const coerce = (ctx, name, args) => {
+export 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) {
@@ -11,20 +12,22 @@ const coerce = (ctx, name, args) => {
             return "";
     }
     const raw = args[0];
-    if (name === "Number")
-        return coerceToNumber(raw);
     if (name === "Boolean")
         return Boolean(raw);
-    if (name === "isFinite")
-        return Number.isFinite(coerceToNumber(raw));
-    if (name === "isNaN")
-        return Number.isNaN(coerceToNumber(raw));
     if (name === "parseInt") {
-        return parseInt(coerceToString(raw), coerceToNumber(args[1]));
+        return withPrimitives(ctx, ["string", "number"], [raw, args[1]], ([text, radix]) => parseInt(coerceToString(text), coerceToNumber(radix)));
     }
-    if (name === "parseFloat")
-        return parseFloat(coerceToString(raw));
-    return coerceToString(raw);
+    return withPrimitives(ctx, name === "String" || name === "parseFloat" ? "string" : "number", [raw], ([value]) => {
+        if (name === "Number")
+            return coerceToNumber(value);
+        if (name === "isFinite")
+            return Number.isFinite(coerceToNumber(value));
+        if (name === "isNaN")
+            return Number.isNaN(coerceToNumber(value));
+        if (name === "parseFloat")
+            return parseFloat(coerceToString(value));
+        return coerceToString(value);
+    });
 };
 /** A global coercion function such as `Number` or `parseInt`. */
 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,5 @@
 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 structuredCloneGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
 export declare const cryptoGlobal: <R>(ctx: Interpreter<R>) => Obj;

package/dist/stdlib/web.js

@@ -1,7 +1,9 @@
 import { fn, methods } from "../interpreter/native.js";
 import { typeError } from "../interpreter/model.js";
-import { Bytes, Obj, coerceToString } from "../interpreter/objects.js";
+import { define, entries, get, getOwn, hasOwn, hidden, isRuntimeReference, Arr, Bytes, DateObj, ErrorObj, MapObj, Obj, RegExpObj, SetObj, WeakMapObj, WeakSetObj, coerceToString, } from "../interpreter/objects.js";
+import { createErrorValue, isErrorType } from "../interpreter/intrinsics.js";
 import { describeValue } from "../interpreter/references.js";
+import { ToolReference } from "../tool-runtime.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) => {
@@ -15,6 +17,66 @@ export const base64Global = (ctx, name) => fn(ctx.builtins, name, 1, (_, args) =
         throw typeError("The string contains invalid characters.");
     }
 });
+// HTML structured clone over CodeMode's data kinds. Shared references survive through the memo; prototypes and
+// frozen state do not, as in JS. Without a DOMException, DataCloneError is a TypeError carrying that prefix.
+export const structuredCloneGlobal = (ctx) => fn(ctx.builtins, "structuredClone", 1, (_, args) => {
+    if (args.length === 0)
+        throw typeError("structuredClone requires 1 argument");
+    const builtins = ctx.builtins;
+    const memo = new Map();
+    const clone = (value) => {
+        if (typeof value === "symbol" || value instanceof ToolReference) {
+            throw typeError(`DataCloneError: ${describeValue(value)} could not be cloned.`);
+        }
+        if (!(value instanceof Obj))
+            return value;
+        const seen = memo.get(value);
+        if (seen !== undefined)
+            return seen;
+        const remember = (copy) => {
+            memo.set(value, copy);
+            return copy;
+        };
+        if (value instanceof MapObj) {
+            const copy = remember(new MapObj(builtins.Map));
+            for (const [key, item] of value.map)
+                copy.map.set(clone(key), clone(item));
+            return copy;
+        }
+        if (value instanceof SetObj) {
+            const copy = remember(new SetObj(builtins.Set));
+            for (const item of value.set)
+                copy.set.add(clone(item));
+            return copy;
+        }
+        if (value instanceof DateObj)
+            return remember(new DateObj(builtins.Date, value.time));
+        if (value instanceof RegExpObj) {
+            return remember(new RegExpObj(builtins.RegExp, value.regex.source, value.regex.flags));
+        }
+        if (value instanceof Bytes)
+            return remember(new Bytes(builtins.Uint8Array, new Uint8Array(value.bytes)));
+        if (value instanceof ErrorObj) {
+            const name = get(value, "name");
+            const message = get(value, "message");
+            const copy = remember(createErrorValue(builtins[typeof name === "string" && isErrorType(name) ? name : "Error"], message === undefined ? undefined : coerceToString(message)));
+            const stack = getOwn(value, "stack");
+            if (typeof stack === "string")
+                define(copy, "stack", stack, hidden);
+            if (hasOwn(value, "cause"))
+                define(copy, "cause", clone(getOwn(value, "cause")), hidden);
+            return copy;
+        }
+        if (isRuntimeReference(value) || value instanceof WeakMapObj || value instanceof WeakSetObj) {
+            throw typeError(`DataCloneError: ${describeValue(value)} could not be cloned.`);
+        }
+        const copy = remember(value instanceof Arr ? new Arr(builtins.Array, new Array(value.items.length)) : new Obj(builtins.Object));
+        for (const [key, item] of entries(value))
+            define(copy, key, clone(item));
+        return copy;
+    };
+    return clone(args[0]);
+});
 export const cryptoGlobal = (ctx) => {
     const object = new Obj(ctx.builtins.Object);
     methods(ctx.builtins, object, [

package/package.json

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