@opencode/codemode 2.0.32 → 2.1.0

package/dist/stdlib/array.js

@@ -335,10 +335,12 @@ export const arrayGlobal = (ctx) => {
                         if (!(index in target.items))
                             continue;
                         const mapped = yield* apply([target.items[index], index, target], args[1]);
-                        if (mapped instanceof Arr)
-                            values.push(...mapped.items);
-                        else
-                            values.push(mapped);
+                        if (mapped instanceof Arr) {
+                            // forEach skips holes, as flattening does; spreading would turn them into undefined.
+                            mapped.items.forEach((item) => values.push(item));
+                            continue;
+                        }
+                        values.push(mapped);
                     }
                     return wrap(values);
                 });

package/dist/stdlib/bytes.js

@@ -4,10 +4,15 @@ import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../i
 import { IteratorSymbol, rangeError, syntaxError, typeError } from "../interpreter/model.js";
 import { define, defineAccessor, get, hidden, Arr, Bytes, hostIterator, Obj, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { describeValue } from "../interpreter/references.js";
+import { applyCollectionCallback } from "../interpreter/callback.js";
 import { callbackMethods, sortArray } from "./array.js";
-/** The bytes a Uint8Array, array, or other iterable of numbers describes; the host array clamps each value. */
-const collectBytes = (ctx, source, name) => {
-    if (source instanceof Bytes)
+/**
+ * The bytes a Uint8Array, array, or other iterable of numbers describes; the host array clamps each value. As in
+ * TypedArray.from, a mapper sees the original values, after the source is consumed in full.
+ */
+const collectBytes = (ctx, source, name, mapper, thisArg) => {
+    const apply = mapper === undefined ? undefined : applyCollectionCallback(ctx, mapper, name);
+    if (source instanceof Bytes && apply === undefined)
         return Effect.succeed(new Uint8Array(source.bytes));
     return Effect.gen(function* () {
         const cursor = yield* ctx.iterate(source);
@@ -18,10 +23,12 @@ const collectBytes = (ctx, source, name) => {
         while (true) {
             const step = yield* cursor.next;
             if (step.done)
-                return Uint8Array.from(values);
-            values.push(coerceToNumber(step.value));
+                break;
+            values.push(step.value);
             checkArrayLength(values.length);
         }
+        const mapped = apply === undefined ? values : yield* Effect.forEach(values, (value, index) => apply([value, index], thisArg));
+        return Uint8Array.from(mapped, coerceToNumber);
     });
 };
 const constructBytes = (ctx, args, proto) => {
@@ -56,13 +63,15 @@ export const uint8ArrayGlobal = (ctx) => {
         }
     };
     methods(builtins, uint8Array, [
-        ["from", 1, (_, args) => Effect.map(collectBytes(ctx, args[0], "Uint8Array.from"), wrap)],
+        ["from", 1, (_, args) => Effect.map(collectBytes(ctx, args[0], "Uint8Array.from", args[1], args[2]), wrap)],
         ["of", 0, (_, args) => wrap(Uint8Array.from(args, coerceToNumber))],
         ["fromBase64", 1, (_, args) => decode("fromBase64", args, (text) => Uint8Array.fromBase64(text))],
         ["fromHex", 1, (_, args) => decode("fromHex", args, (text) => Uint8Array.fromHex(text))],
     ]);
     const self = (thisValue, name) => receiver(Bytes, thisValue, `Uint8Array.prototype.${name}`);
     const optNumber = (value) => (value === undefined ? undefined : coerceToInteger(value));
+    // Uint8Array cannot contain NaN, so non-number search values never match a byte.
+    const search = (value) => (typeof value === "number" ? value : NaN);
     const wrapAll = (items) => new Arr(builtins.Array, items);
     defineAccessor(proto, "length", (thisValue) => self(thisValue, "length").bytes.length);
     methods(builtins, proto, [
@@ -127,25 +136,21 @@ export const uint8ArrayGlobal = (ctx) => {
                 });
             },
         ],
-        [
-            "indexOf",
-            1,
-            (thisValue, args) => self(thisValue, "indexOf").bytes.indexOf(coerceToNumber(args[0]), optNumber(args[1])),
-        ],
+        ["indexOf", 1, (thisValue, args) => self(thisValue, "indexOf").bytes.indexOf(search(args[0]), optNumber(args[1]))],
         [
             "lastIndexOf",
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "lastIndexOf").bytes;
                 return args.length < 2
-                    ? target.lastIndexOf(coerceToNumber(args[0]))
-                    : target.lastIndexOf(coerceToNumber(args[0]), optNumber(args[1]));
+                    ? target.lastIndexOf(search(args[0]))
+                    : target.lastIndexOf(search(args[0]), optNumber(args[1]));
             },
         ],
         [
             "includes",
             1,
-            (thisValue, args) => self(thisValue, "includes").bytes.includes(coerceToNumber(args[0]), optNumber(args[1])),
+            (thisValue, args) => self(thisValue, "includes").bytes.includes(search(args[0]), optNumber(args[1])),
         ],
         [
             "join",

package/dist/stdlib/number.js

@@ -1,6 +1,6 @@
 import { constructor, constants, methods } from "../interpreter/native.js";
 import { coerceToNumber } from "../interpreter/objects.js";
-import { rangeError, typeError } from "../interpreter/model.js";
+import { typeError } from "../interpreter/model.js";
 import { withPrimitives } from "../interpreter/callback.js";
 import { coerce, coercion } from "./value.js";
 export const numberGlobal = (ctx) => {
@@ -47,12 +47,7 @@ export const numberGlobal = (ctx) => {
         ["toLocaleString", 0, (thisValue) => self(thisValue, "toLocaleString").toLocaleString("en-US")],
         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);
-        }),
+        formatting("toString", (value, radix) => value.toString(radix)),
         ["valueOf", 0, (thisValue) => self(thisValue, "valueOf")],
     ]);
     return number;

package/dist/stdlib/value.d.ts

@@ -2,6 +2,6 @@ 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>;
+export declare const coerce: <R>(ctx: Interpreter<R>, name: Coercion, args: Array<Value>) => import("effect/Effect").Effect<Value, unknown, R> | Value;
 /** 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/tool-runtime.d.ts

@@ -4,7 +4,7 @@ import type { DiagnosticKind } from "./codemode.js";
 import { type Namespace } from "./namespace.js";
 import { type Tool } from "./tool.js";
 import type { Tools } from "./tools.js";
-export declare const compareText: (left: string, right: string) => 0 | 1 | -1;
+export declare const compareText: (left: string, right: string) => -1 | 0 | 1;
 export type Services<T> = ServicesOf<T, []>;
 type ServicesOf<T, Depth extends ReadonlyArray<unknown>> = Depth["length"] extends 8 ? never : T extends {
     readonly _tag: "CodeModeTool";

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "2.0.32",
+  "version": "2.1.0",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",
@@ -24,7 +24,7 @@
   },
   "scripts": {
     "build": "bun run script/build.ts",
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsc --noEmit",
     "test": "bun test"
   },
   "dependencies": {
@@ -34,6 +34,6 @@
   "devDependencies": {
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
-    "@typescript/native-preview": "7.0.0-dev.20251207.1"
+    "@typescript/native": "npm:typescript@7.0.2"
   }
 }