@opencode/codemode 0.0.0-dev-19971 → 0.0.0-dev-19974

package/dist/interpreter/objects.d.ts

@@ -217,6 +217,8 @@ export type Value = string | number | boolean | null | undefined | symbol | Obj
 export declare const coerceToString: (value: Value) => string;
 /** ToNumber without consulting program-defined methods; tool references are not numbers. */
 export declare const coerceToNumber: (value: Value) => number;
+/** ToIntegerOrInfinity: NaN is 0, fractions truncate. */
+export declare const coerceToInteger: (value: Value) => number;
 /** Values that cannot cross the data boundary: opaque machinery and host-backed wrappers. */
 export declare const isRuntimeReference: (value: Value) => boolean;
 export declare const parseArrayIndex: (key: string | number) => number | undefined;

package/dist/interpreter/objects.js

@@ -337,6 +337,11 @@ export const coerceToNumber = (value) => {
         return value.toNumber();
     return value instanceof ToolReference ? Number.NaN : Number(value);
 };
+/** ToIntegerOrInfinity: NaN is 0, fractions truncate. */
+export const coerceToInteger = (value) => {
+    const number = coerceToNumber(value);
+    return Number.isNaN(number) ? 0 : Math.trunc(number);
+};
 /** Values that cannot cross the data boundary: opaque machinery and host-backed wrappers. */
 export const isRuntimeReference = (value) => value instanceof Opaque || value instanceof Wrapper || value instanceof ToolReference;
 const MAX_ARRAY_INDEX = 4_294_967_295;

package/dist/stdlib/array.js

@@ -2,16 +2,16 @@ import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interpreter/limits.js";
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
-import { define, get, hidden, Arr, GeneratorObj, hostIterator, Obj, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
+import { define, get, hidden, Arr, GeneratorObj, hostIterator, Obj, PromiseObj, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
 import { applyCollectionCallback, invoke, preserveConsumerError } from "../interpreter/callback.js";
 import { compareText } from "../tool-runtime.js";
 const arrayLikeSource = (source) => {
-    if (source instanceof Obj && typeof get(source, "length") === "number") {
-        const length = get(source, "length");
-        const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length);
-        checkArrayLength(normalized);
-        return { length: normalized, source };
+    // JS would treat a promise as an empty array-like; that would hide a missing `await`.
+    if (source instanceof Obj && !(source instanceof PromiseObj)) {
+        const length = Math.max(0, coerceToInteger(get(source, "length")));
+        checkArrayLength(length);
+        return { length, source };
     }
     throw invalidData(`Array.from expects an iterable or array-like value, received ${describeValue(source)}.`);
 };
@@ -102,14 +102,7 @@ export const arrayGlobal = (ctx) => {
         ["from", 1, (_, args) => arrayFrom(ctx, args)],
     ]);
     const self = (thisValue, name) => receiver(Arr, thisValue, `Array.prototype.${name}`);
-    const optNumber = (name, value, label) => {
-        if (value === undefined)
-            return undefined;
-        if (typeof value !== "number") {
-            throw typeError(`Array.${name} expects ${label} to be a number.`);
-        }
-        return value;
-    };
+    const optNumber = (value) => (value === undefined ? undefined : coerceToInteger(value));
     // Callback methods fix the iteration length while reading existing elements live.
     const iterate = (name, length, body) => [
         name,
@@ -124,13 +117,9 @@ export const arrayGlobal = (ctx) => {
             "join",
             1,
             (thisValue, args) => {
-                const target = self(thisValue, "join").items;
-                if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
-                    throw typeError("Array.join expects zero arguments or one string separator.");
-                }
-                const joined = target
-                    .map((item) => coerceToString(item ?? ""))
-                    .join(args.length === 0 ? "," : args[0]);
+                const joined = self(thisValue, "join")
+                    .items.map((item) => coerceToString(item ?? ""))
+                    .join(args[0] === undefined ? "," : coerceToString(args[0]));
                 checkStringLength(joined.length);
                 return joined;
             },
@@ -146,33 +135,23 @@ export const arrayGlobal = (ctx) => {
             "includes",
             1,
             (thisValue, args) => {
-                const target = self(thisValue, "includes").items;
-                if (args.length === 0 || args.length > 2) {
-                    throw typeError("Array.includes expects a value and optional start index.");
-                }
-                return target.includes(args[0], optNumber("includes", args[1], "start index"));
+                return self(thisValue, "includes").items.includes(args[0], optNumber(args[1]));
             },
         ],
-        [
-            "indexOf",
-            1,
-            (thisValue, args) => self(thisValue, "indexOf").items.indexOf(args[0], optNumber("indexOf", args[1], "start index")),
-        ],
+        ["indexOf", 1, (thisValue, args) => self(thisValue, "indexOf").items.indexOf(args[0], optNumber(args[1]))],
         [
             "lastIndexOf",
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "lastIndexOf").items;
-                return args[1] === undefined
-                    ? target.lastIndexOf(args[0])
-                    : target.lastIndexOf(args[0], optNumber("lastIndexOf", args[1], "start index"));
+                return args[1] === undefined ? target.lastIndexOf(args[0]) : target.lastIndexOf(args[0], optNumber(args[1]));
             },
         ],
-        ["at", 1, (thisValue, args) => self(thisValue, "at").items.at(optNumber("at", args[0], "index") ?? 0)],
+        ["at", 1, (thisValue, args) => self(thisValue, "at").items.at(optNumber(args[0]) ?? 0)],
         [
             "slice",
             2,
-            (thisValue, args) => wrap(self(thisValue, "slice").items.slice(optNumber("slice", args[0], "start"), optNumber("slice", args[1], "end"))),
+            (thisValue, args) => wrap(self(thisValue, "slice").items.slice(optNumber(args[0]), optNumber(args[1]))),
         ],
         [
             "concat",
@@ -188,7 +167,7 @@ export const arrayGlobal = (ctx) => {
             0,
             (thisValue, args) => {
                 const flatten = (items, depth) => items.flatMap((item) => (item instanceof Arr && depth > 0 ? flatten(item.items, depth - 1) : [item]));
-                const flattened = flatten(self(thisValue, "flat").items, optNumber("flat", args[0], "depth") ?? 1);
+                const flattened = flatten(self(thisValue, "flat").items, optNumber(args[0]) ?? 1);
                 checkArrayLength(flattened.length);
                 return wrap(flattened);
             },
@@ -233,7 +212,7 @@ export const arrayGlobal = (ctx) => {
             2,
             (thisValue, args) => {
                 const target = self(thisValue, "with").items;
-                const index = optNumber("with", args[0], "index") ?? 0;
+                const index = optNumber(args[0]) ?? 0;
                 const resolved = index < 0 ? target.length + index : index;
                 if (resolved < 0 || resolved >= target.length)
                     throw rangeError("Array.with index is out of range.");
@@ -272,10 +251,10 @@ export const arrayGlobal = (ctx) => {
                 const target = self(thisValue, "splice");
                 if (args.length === 0)
                     return wrap(target.items.splice(0, 0));
-                const start = optNumber("splice", args[0], "start") ?? 0;
+                const start = optNumber(args[0]) ?? 0;
                 if (args.length === 1)
                     return wrap(target.items.splice(start));
-                const deleteCount = optNumber("splice", args[1], "delete count") ?? 0;
+                const deleteCount = optNumber(args[1]) ?? 0;
                 const inserted = args.slice(2);
                 for (const item of inserted)
                     rejectCircularInsertion(target, item, "Array.splice result");
@@ -289,11 +268,11 @@ export const arrayGlobal = (ctx) => {
                 const copied = [...self(thisValue, "toSpliced").items];
                 if (args.length === 0)
                     return wrap(copied);
-                const start = optNumber("toSpliced", args[0], "start") ?? 0;
+                const start = optNumber(args[0]) ?? 0;
                 if (args.length === 1)
                     copied.splice(start);
                 else
-                    copied.splice(start, optNumber("toSpliced", args[1], "delete count") ?? 0, ...args.slice(2));
+                    copied.splice(start, optNumber(args[1]) ?? 0, ...args.slice(2));
                 return wrap(copied);
             },
         ],
@@ -303,7 +282,7 @@ export const arrayGlobal = (ctx) => {
             (thisValue, args) => {
                 const target = self(thisValue, "fill");
                 rejectCircularInsertion(target, args[0], "Array.fill result");
-                target.items.fill(args[0], optNumber("fill", args[1], "start"), optNumber("fill", args[2], "end"));
+                target.items.fill(args[0], optNumber(args[1]), optNumber(args[2]));
                 return target;
             },
         ],
@@ -312,7 +291,7 @@ export const arrayGlobal = (ctx) => {
             2,
             (thisValue, args) => {
                 const target = self(thisValue, "copyWithin");
-                target.items.copyWithin(optNumber("copyWithin", args[0], "target index") ?? 0, optNumber("copyWithin", args[1], "start") ?? 0, optNumber("copyWithin", args[2], "end"));
+                target.items.copyWithin(optNumber(args[0]) ?? 0, optNumber(args[1]) ?? 0, optNumber(args[2]));
                 return target;
             },
         ],

package/dist/stdlib/bytes.js

@@ -2,7 +2,7 @@ import { Effect } from "effect";
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { IteratorSymbol, rangeError, syntaxError, typeError } from "../interpreter/model.js";
-import { define, defineAccessor, get, hidden, Arr, Bytes, hostIterator, Obj, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
+import { define, defineAccessor, get, hidden, Arr, Bytes, hostIterator, Obj, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { describeValue } from "../interpreter/references.js";
 /** The bytes a Uint8Array, array, or other iterable of numbers describes; the host array clamps each value. */
 const collectBytes = (ctx, source, name) => {
@@ -61,34 +61,28 @@ export const uint8ArrayGlobal = (ctx) => {
         ["fromHex", 1, (_, args) => decode("fromHex", args, (text) => Uint8Array.fromHex(text))],
     ]);
     const self = (thisValue, name) => receiver(Bytes, thisValue, `Uint8Array.prototype.${name}`);
-    const optNumber = (name, value, label) => {
-        if (value === undefined)
-            return undefined;
-        if (typeof value !== "number")
-            throw typeError(`Uint8Array.${name} expects ${label} to be a number.`);
-        return value;
-    };
+    const optNumber = (value) => (value === undefined ? undefined : coerceToInteger(value));
     const wrapAll = (items) => new Arr(builtins.Array, items);
     defineAccessor(proto, "length", (thisValue) => self(thisValue, "length").bytes.length);
     methods(builtins, proto, [
-        ["at", 1, (thisValue, args) => self(thisValue, "at").bytes.at(optNumber("at", args[0], "index") ?? 0)],
+        ["at", 1, (thisValue, args) => self(thisValue, "at").bytes.at(optNumber(args[0]) ?? 0)],
         [
             "slice",
             2,
-            (thisValue, args) => wrap(self(thisValue, "slice").bytes.slice(optNumber("slice", args[0], "start"), optNumber("slice", args[1], "end"))),
+            (thisValue, args) => wrap(self(thisValue, "slice").bytes.slice(optNumber(args[0]), optNumber(args[1]))),
         ],
         // A view on the same bytes, as in JS: writes through one are visible through the other.
         [
             "subarray",
             2,
-            (thisValue, args) => wrap(self(thisValue, "subarray").bytes.subarray(optNumber("subarray", args[0], "start"), optNumber("subarray", args[1], "end"))),
+            (thisValue, args) => wrap(self(thisValue, "subarray").bytes.subarray(optNumber(args[0]), optNumber(args[1]))),
         ],
         [
             "set",
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "set");
-                const offset = optNumber("set", args[1], "offset") ?? 0;
+                const offset = optNumber(args[1]) ?? 0;
                 return Effect.map(collectBytes(ctx, args[0], "Uint8Array.set"), (source) => {
                     if (!Number.isInteger(offset) || offset < 0 || source.length + offset > target.bytes.length) {
                         throw rangeError("Uint8Array.set: the source does not fit at that offset.");
@@ -103,7 +97,7 @@ export const uint8ArrayGlobal = (ctx) => {
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "fill");
-                target.bytes.fill(coerceToNumber(args[0]), optNumber("fill", args[1], "start"), optNumber("fill", args[2], "end"));
+                target.bytes.fill(coerceToNumber(args[0]), optNumber(args[1]), optNumber(args[2]));
                 return target;
             },
         ],
@@ -119,7 +113,7 @@ export const uint8ArrayGlobal = (ctx) => {
         [
             "indexOf",
             1,
-            (thisValue, args) => self(thisValue, "indexOf").bytes.indexOf(coerceToNumber(args[0]), optNumber("indexOf", args[1], "start index")),
+            (thisValue, args) => self(thisValue, "indexOf").bytes.indexOf(coerceToNumber(args[0]), optNumber(args[1])),
         ],
         [
             "lastIndexOf",
@@ -128,22 +122,19 @@ export const uint8ArrayGlobal = (ctx) => {
                 const target = self(thisValue, "lastIndexOf").bytes;
                 return args[1] === undefined
                     ? target.lastIndexOf(coerceToNumber(args[0]))
-                    : target.lastIndexOf(coerceToNumber(args[0]), optNumber("lastIndexOf", args[1], "start index"));
+                    : target.lastIndexOf(coerceToNumber(args[0]), optNumber(args[1]));
             },
         ],
         [
             "includes",
             1,
-            (thisValue, args) => self(thisValue, "includes").bytes.includes(coerceToNumber(args[0]), optNumber("includes", args[1], "start index")),
+            (thisValue, args) => self(thisValue, "includes").bytes.includes(coerceToNumber(args[0]), optNumber(args[1])),
         ],
         [
             "join",
             1,
             (thisValue, args) => {
-                if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
-                    throw typeError("Uint8Array.join expects zero arguments or one string separator.");
-                }
-                const joined = self(thisValue, "join").bytes.join(args.length === 0 ? "," : args[0]);
+                const joined = self(thisValue, "join").bytes.join(args[0] === undefined ? "," : coerceToString(args[0]));
                 checkStringLength(joined.length);
                 return joined;
             },

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;

package/dist/stdlib/number.js

@@ -1,5 +1,5 @@
 import { constructor, constants, methods } from "../interpreter/native.js";
-import { coerceToString } from "../interpreter/objects.js";
+import { coerceToNumber, coerceToString } from "../interpreter/objects.js";
 import { rangeError, typeError } from "../interpreter/model.js";
 import { coercion } from "./value.js";
 export const numberGlobal = (ctx) => {
@@ -28,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]))],
@@ -42,27 +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]))],
+        ["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("toExponential", args[0])),
-        ],
+        ["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);
             },
         ],
@@ -71,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/string.js

@@ -73,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),

package/dist/stdlib/value.js

@@ -1,5 +1,4 @@
 import { fn } from "../interpreter/native.js";
-import { typeError } from "../interpreter/model.js";
 import { coerceToNumber, coerceToString } from "../interpreter/objects.js";
 export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="]);
 const coerce = (ctx, name, args) => {
@@ -21,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/package.json

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