@opencode/codemode 0.0.0-dev-20148 → 0.0.0-dev-20150

package/dist/interpreter/callback.d.ts

@@ -16,9 +16,9 @@ export declare const invoke: <R>(ctx: Interpreter<R>, value: Value, name: string
 export declare const toPrimitiveString: <R>(ctx: Interpreter<R>, value: Value) => Effect.Effect<string, unknown, R>;
 export declare const toPrimitiveNumber: <R>(ctx: Interpreter<R>, value: Value) => Effect.Effect<number, unknown, R>;
 /**
- * Runs a synchronous native body on its arguments after ToPrimitive, in order, with one hint for all positions or
- * one per position. Primitive arguments skip the Effect entirely.
+ * Runs a native body on its arguments after ToPrimitive, in order, with one hint for all positions or one per
+ * position. Primitive arguments skip the Effect entirely.
  */
-export declare const withPrimitives: <R>(ctx: Interpreter<R>, hints: Hint | ReadonlyArray<Hint>, values: Array<Value>, body: (primitives: Array<Value>) => Value) => Value | Effect.Effect<Value, unknown, R>;
+export declare const withPrimitives: <R>(ctx: Interpreter<R>, hints: Hint | ReadonlyArray<Hint>, values: Array<Value>, body: (primitives: Array<Value>) => Value | Effect.Effect<Value, unknown, R>) => Value | Effect.Effect<Value, unknown, R>;
 export declare const isSupportedCallback: (value: Value) => value is Callable;
 export declare const applyCollectionCallback: <R>(ctx: Interpreter<R>, callback: Value, name: string) => ((args: Array<Value>, thisValue?: Value) => Effect.Effect<Value, unknown, R>);

package/dist/interpreter/callback.js

@@ -47,13 +47,16 @@ export const invoke = (ctx, value, name, label) => {
 export const toPrimitiveString = (ctx, value) => Effect.map(toPrimitive(ctx, value, "string"), coerceToString);
 export const toPrimitiveNumber = (ctx, value) => Effect.map(toPrimitive(ctx, value, "number"), coerceToNumber);
 /**
- * Runs a synchronous native body on its arguments after ToPrimitive, in order, with one hint for all positions or
- * one per position. Primitive arguments skip the Effect entirely.
+ * Runs a native body on its arguments after ToPrimitive, in order, with one hint for all positions or one per
+ * position. Primitive arguments skip the Effect entirely.
  */
 export const withPrimitives = (ctx, hints, values, body) => {
     if (!values.some((value) => value instanceof Obj))
         return body(values);
-    return Effect.map(Effect.forEach(values, (value, index) => toPrimitive(ctx, value, typeof hints === "string" ? hints : hints[index])), body);
+    return Effect.flatMap(Effect.forEach(values, (value, index) => toPrimitive(ctx, value, typeof hints === "string" ? hints : hints[index])), (primitives) => {
+        const result = body(primitives);
+        return Effect.isEffect(result) ? result : Effect.succeed(result);
+    });
 };
 // The single acceptance list for callbacks: collections, sort, string replacers,
 // Array.from mappers, and promise reactions all admit exactly these callables.

package/dist/interpreter/interpreter.js

@@ -33,6 +33,8 @@ const primitiveOperators = new Set([
     ">>",
     ">>>",
 ]);
+/** ToPropertyKey on a primitive (or an opaque value, which keeps its built-in string form). */
+const propertyKey = (value) => typeof value === "string" || typeof value === "number" || typeof value === "symbol" ? value : coerceToString(value);
 // What a loop does with its body's result: exit with a StatementResult, or undefined to keep iterating.
 // Unlabelled break ends this loop; a label the loop does not carry propagates outward.
 const loopExit = (result, labels) => {
@@ -999,7 +1001,7 @@ class Frame {
         }
         const keyNode = property.key;
         if (property.computed) {
-            return Effect.map(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value));
+            return Effect.flatMap(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value, keyNode));
         }
         if (keyNode.type === "Identifier")
             return Effect.succeed(keyNode.name);
@@ -1120,6 +1122,10 @@ class Frame {
         // IsLooselyEqual converts only an object facing a non-nullish primitive; two objects (including tool
         // references, which are not Obj) compare by identity.
         const equality = operator === "==" || operator === "!=";
+        // `in` checks the right operand before ToPropertyKey on the left, so a bad right side wins over a bad key.
+        if (operator === "in" && lhs instanceof Obj && !isOpaque(lhs) && rhs instanceof Obj) {
+            return Effect.map(this.toPropertyKey(lhs, node), (key) => has(rhs, key));
+        }
         const other = lhs instanceof Obj ? rhs : lhs;
         const converts = primitiveOperators.has(operator) ||
             (equality && other !== null && other !== undefined && typeof other !== "object");
@@ -1142,9 +1148,8 @@ class Frame {
             return this.looselyEqual(lhs, rhs, node);
         if (operator === "!=")
             return !this.looselyEqual(lhs, rhs, node);
-        if (operator === "in" && rhs instanceof Obj && !isOpaque(lhs)) {
-            return has(rhs, lhs !== null && typeof lhs === "object" ? coerceToString(lhs) : lhs);
-        }
+        if (operator === "in" && rhs instanceof Obj && !isOpaque(lhs))
+            return has(rhs, propertyKey(lhs));
         if (isOpaque(lhs) || isOpaque(rhs)) {
             throw invalidData("Binary operators require data values.", node);
         }
@@ -1709,13 +1714,13 @@ class Frame {
                 const keyNode = property.key;
                 let key;
                 if (property.computed) {
-                    key = self.toPropertyKey(yield* self.evaluateExpression(keyNode));
+                    key = yield* self.toPropertyKey(yield* self.evaluateExpression(keyNode), keyNode);
                 }
                 else if (keyNode.type === "Identifier") {
                     key = keyNode.name;
                 }
                 else if (keyNode.type === "Literal") {
-                    key = self.toPropertyKey(literal(keyNode));
+                    key = propertyKey(literal(keyNode));
                 }
                 else {
                     throw typeError("Unsupported object property key shape.", keyNode);
@@ -1820,11 +1825,15 @@ class Frame {
                 return OptionalShortCircuit;
             if ((objectValue === null || objectValue === undefined) && node.optional)
                 return OptionalShortCircuit;
-            const key = node.computed
-                ? self.toPropertyKey(yield* self.evaluateExpression(propertyNode))
-                : propertyNode.type === "Identifier"
-                    ? propertyNode.name
-                    : self.toPropertyKey(yield* self.evaluateExpression(propertyNode));
+            const keyValue = !node.computed && propertyNode.type === "Identifier"
+                ? propertyNode.name
+                : yield* self.evaluateExpression(propertyNode);
+            // GetValue applies ToObject to the base before ToPropertyKey, so a nullish base throws before the key's own
+            // toString runs.
+            if (objectValue === null || objectValue === undefined) {
+                throw typeError(`Cannot read properties of ${objectValue} (reading '${coerceToString(keyValue)}').`, objectNode);
+            }
+            const key = yield* self.toPropertyKey(keyValue, propertyNode);
             return self.resolveProperty(objectValue, key, objectNode, propertyNode);
         });
     }
@@ -1942,10 +1951,11 @@ class Frame {
             return;
         throw typeError(`Cannot assign to read only property '${String(key)}'.`, node);
     }
-    // ToPropertyKey: anything else becomes its string form, so `counts[row.category]` works when the field is null.
-    toPropertyKey(value) {
-        if (typeof value === "string" || typeof value === "number" || typeof value === "symbol")
-            return value;
-        return coerceToString(value);
+    // ToPropertyKey: a data object converts through its own `toString`/`valueOf` first; anything else becomes its
+    // string form synchronously, so `counts[row.category]` works when the field is null.
+    toPropertyKey(value, node) {
+        if (!(value instanceof Obj))
+            return Effect.succeed(propertyKey(value));
+        return Effect.map(this.toPrimitive(value, "string", node), propertyKey);
     }
 }

package/dist/stdlib/array.js

@@ -29,7 +29,7 @@ const arrayFrom = (ctx, args) => {
             const values = [];
             for (let index = 0; index < arrayLike.length; index += 1) {
                 const item = get(arrayLike.source, index);
-                values.push(apply === undefined ? item : yield* apply([item, index]));
+                values.push(apply === undefined ? item : yield* apply([item, index], args[2]));
             }
             return new Arr(proto, values);
         }
@@ -39,7 +39,9 @@ const arrayFrom = (ctx, args) => {
             const step = yield* cursor.next;
             if (step.done)
                 return new Arr(proto, values);
-            values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor.close, apply([step.value, index])));
+            values.push(apply === undefined
+                ? step.value
+                : yield* preserveConsumerError(cursor.close, apply([step.value, index], args[2])));
             index += 1;
         }
     });
@@ -332,7 +334,7 @@ export const arrayGlobal = (ctx) => {
                     for (let index = 0; index < length; index += 1) {
                         if (!(index in target.items))
                             continue;
-                        const mapped = yield* apply([target.items[index], index, target]);
+                        const mapped = yield* apply([target.items[index], index, target], args[1]);
                         if (mapped instanceof Arr)
                             values.push(...mapped.items);
                         else
@@ -357,7 +359,10 @@ export const callbackMethods = (ctx, label, self, elements, wrap) => {
         length,
         (thisValue, args) => {
             const target = self(thisValue, name);
-            return body(elements(target), target, applyCollectionCallback(ctx, args[0], `${label}.${name}`), args);
+            const call = applyCollectionCallback(ctx, args[0], `${label}.${name}`);
+            // reduce and reduceRight take an initial value where the others take a thisArg.
+            const thisArg = name.startsWith("reduce") ? undefined : args[1];
+            return body(elements(target), target, (callbackArgs) => call(callbackArgs, thisArg), args);
         },
     ];
     return [

package/dist/stdlib/collections.js

@@ -167,7 +167,7 @@ export const mapGlobal = (ctx) => {
                 const apply = applyCollectionCallback(ctx, args[0], "Map.forEach");
                 return Effect.gen(function* () {
                     for (const [key, item] of target.map.entries())
-                        yield* apply([item, key, target]);
+                        yield* apply([item, key, target], args[1]);
                     return undefined;
                 });
             },
@@ -357,7 +357,7 @@ export const setGlobal = (ctx) => {
                 const apply = applyCollectionCallback(ctx, args[0], "Set.forEach");
                 return Effect.gen(function* () {
                     for (const item of target.set.values())
-                        yield* apply([item, item, target]);
+                        yield* apply([item, item, target], args[1]);
                     return undefined;
                 });
             },

package/dist/stdlib/headers.js

@@ -104,7 +104,7 @@ export const headersGlobal = (ctx) => {
                 const apply = applyCollectionCallback(ctx, args[0], "Headers.forEach");
                 return Effect.gen(function* () {
                     for (const [key, value] of Array.from(target.headers.entries()))
-                        yield* apply([value, key, target]);
+                        yield* apply([value, key, target], args[1]);
                     return undefined;
                 });
             },

package/dist/stdlib/number.js

@@ -1,6 +1,7 @@
 import { constructor, constants, methods } from "../interpreter/native.js";
 import { coerceToNumber } from "../interpreter/objects.js";
 import { rangeError, typeError } from "../interpreter/model.js";
+import { withPrimitives } from "../interpreter/callback.js";
 import { coerce, coercion } from "./value.js";
 export const numberGlobal = (ctx) => {
     const builtins = ctx.builtins;
@@ -32,32 +33,26 @@ export const numberGlobal = (ctx) => {
             return thisValue;
         throw typeError(`Number.prototype.${name} requires that 'this' be a Number.`);
     };
-    const optNum = (arg) => (arg === undefined ? undefined : coerceToNumber(arg));
+    // The receiver is checked first, then the one argument converts through ToPrimitive with the number hint.
+    const formatting = (name, op) => [
+        name,
+        1,
+        (thisValue, args) => {
+            const value = self(thisValue, name);
+            return withPrimitives(ctx, "number", [args[0]], ([digits]) => op(value, digits === undefined ? undefined : coerceToNumber(digits)));
+        },
+    ];
     methods(builtins, builtins.Number, [
-        ["toFixed", 1, (thisValue, args) => self(thisValue, "toFixed").toFixed(optNum(args[0]))],
+        formatting("toFixed", (value, digits) => value.toFixed(digits)),
         ["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(args[0]);
-                return digits === undefined ? value.toString() : value.toPrecision(digits);
-            },
-        ],
-        [
-            "toString",
-            1,
-            (thisValue, args) => {
-                const value = self(thisValue, "toString");
-                const radix = optNum(args[0]);
-                if (radix !== undefined && (radix < 2 || radix > 36)) {
-                    throw rangeError("Number.toString radix must be between 2 and 36.");
-                }
-                return value.toString(radix);
-            },
-        ],
+        formatting("toExponential", (value, digits) => value.toExponential(digits)),
+        formatting("toPrecision", (value, digits) => (digits === undefined ? value.toString() : value.toPrecision(digits))),
+        formatting("toString", (value, radix) => {
+            if (radix !== undefined && (radix < 2 || radix > 36)) {
+                throw rangeError("Number.toString radix must be between 2 and 36.");
+            }
+            return value.toString(radix);
+        }),
         ["valueOf", 0, (thisValue) => self(thisValue, "valueOf")],
     ]);
     return number;

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/package.json

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