@opencode/codemode 2.0.15 → 2.0.17

package/dist/stdlib/collections.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { invalidData, IteratorSymbol, typeError } from "../interpreter/model.js";
-import { define, defineAccessor, get, getOwn, hidden, Arr, coerceToString, hostCursor, hostIterator, MapObj, Obj, PromiseObj, SetObj, } from "../interpreter/objects.js";
+import { define, defineAccessor, get, getOwn, hidden, Arr, coerceToString, hostCursor, hostIterator, MapObj, Obj, PromiseObj, SetObj, WeakMapObj, WeakSetObj, } from "../interpreter/objects.js";
 import { describeValue, isOpaque } from "../interpreter/references.js";
 import { applyCollectionCallback, isSupportedCallback, preserveConsumerError, toPrimitiveNumber, toPrimitiveString, } from "../interpreter/callback.js";
 const coerceGroupByPropertyKey = (ctx, value) => {
@@ -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;
                 });
             },
@@ -373,3 +373,130 @@ export const setGlobal = (ctx) => {
     define(proto, IteratorSymbol, get(proto, "values"), hidden);
     return set;
 };
+// CanBeHeldWeakly: only program objects; tool references are rebuilt on every access, so they could never be found again.
+const weakKey = (value, label) => {
+    if (value instanceof Obj)
+        return value;
+    throw typeError(`Invalid value used ${label}: ${describeValue(value)} cannot be held weakly.`);
+};
+export const weakMapGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.WeakMap;
+    const weakMap = constructor(builtins, proto, {
+        name: "WeakMap",
+        call: requiresNew("WeakMap"),
+        construct: (args, newTarget) => {
+            const target = new WeakMapObj(prototypeFrom(newTarget, proto));
+            if (args[0] === undefined || args[0] === null)
+                return Effect.succeed(target);
+            return Effect.gen(function* () {
+                const cursor = yield* ctx.iterate(args[0]);
+                if (cursor === undefined) {
+                    throw typeError(`new WeakMap(...) expects an iterable of [key, value] pairs, received ${describeValue(args[0])}.`);
+                }
+                while (true) {
+                    const step = yield* cursor.next;
+                    if (step.done)
+                        return target;
+                    yield* preserveConsumerError(cursor.close, Effect.sync(() => {
+                        if (!(step.value instanceof Obj)) {
+                            throw typeError("new WeakMap(...) expects [key, value] pairs as entry objects.");
+                        }
+                        target.map.set(weakKey(getOwn(step.value, 0), "as weak map key"), getOwn(step.value, 1));
+                    }));
+                }
+            });
+        },
+    });
+    const self = (thisValue, name) => receiver(WeakMapObj, thisValue, `WeakMap.prototype.${name}`).map;
+    // Lookups pass any key through: the host collection answers false for a non-object, as the spec requires.
+    const key = (value) => weakKey(value, "as weak map key");
+    methods(builtins, proto, [
+        [
+            "get",
+            1,
+            (thisValue, args) => {
+                const target = self(thisValue, "get");
+                return args[0] instanceof Obj ? target.get(args[0]) : undefined;
+            },
+        ],
+        ["has", 1, (thisValue, args) => self(thisValue, "has").has(args[0])],
+        ["delete", 1, (thisValue, args) => self(thisValue, "delete").delete(args[0])],
+        [
+            "set",
+            2,
+            (thisValue, args) => {
+                self(thisValue, "set").set(key(args[0]), args[1]);
+                return thisValue;
+            },
+        ],
+        [
+            "getOrInsert",
+            2,
+            (thisValue, args) => {
+                const target = self(thisValue, "getOrInsert");
+                const k = key(args[0]);
+                if (!target.has(k))
+                    target.set(k, args[1]);
+                return target.get(k);
+            },
+        ],
+        [
+            "getOrInsertComputed",
+            2,
+            (thisValue, args) => {
+                const target = self(thisValue, "getOrInsertComputed");
+                const k = key(args[0]);
+                const apply = applyCollectionCallback(ctx, args[1], "WeakMap.getOrInsertComputed");
+                if (target.has(k))
+                    return target.get(k);
+                return Effect.map(apply([k]), (value) => {
+                    target.set(k, value);
+                    return value;
+                });
+            },
+        ],
+    ]);
+    return weakMap;
+};
+export const weakSetGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.WeakSet;
+    const weakSet = constructor(builtins, proto, {
+        name: "WeakSet",
+        call: requiresNew("WeakSet"),
+        construct: (args, newTarget) => {
+            const target = new WeakSetObj(prototypeFrom(newTarget, proto));
+            if (args[0] === undefined || args[0] === null)
+                return Effect.succeed(target);
+            return Effect.gen(function* () {
+                const cursor = yield* ctx.iterate(args[0]);
+                if (cursor === undefined) {
+                    throw typeError(`new WeakSet(...) expects a synchronous iterable, received ${describeValue(args[0])}.`);
+                }
+                while (true) {
+                    const step = yield* cursor.next;
+                    if (step.done)
+                        return target;
+                    yield* preserveConsumerError(cursor.close, Effect.sync(() => {
+                        target.set.add(weakKey(step.value, "in weak set"));
+                    }));
+                }
+            });
+        },
+    });
+    const self = (thisValue, name) => receiver(WeakSetObj, thisValue, `WeakSet.prototype.${name}`).set;
+    methods(builtins, proto, [
+        ["has", 1, (thisValue, args) => self(thisValue, "has").has(args[0])],
+        ["delete", 1, (thisValue, args) => self(thisValue, "delete").delete(args[0])],
+        [
+            "add",
+            1,
+            (thisValue, args) => {
+                self(thisValue, "add").add(weakKey(args[0], "in weak set"));
+                return thisValue;
+            },
+        ],
+    ]);
+    return weakSet;
+};

package/dist/stdlib/date.js

@@ -14,8 +14,8 @@ const constructDate = (ctx, args, proto) => {
             ? new DateObj(proto, Date.parse(value))
             : new DateObj(proto, new Date(coerceToNumber(value)).getTime()));
     }
-    const parts = args.map((arg) => coerceToNumber(arg));
-    return Effect.succeed(new DateObj(proto, new Date(...parts).getTime()));
+    // The spec converts at most seven components, in order, so extra arguments never run program code.
+    return Effect.map(Effect.forEach(args.slice(0, 7), (arg) => toPrimitiveNumber(ctx, arg), { concurrency: 1 }), (parts) => new DateObj(proto, new Date(...parts).getTime()));
 };
 const getters = [
     "getFullYear",
@@ -66,7 +66,11 @@ export const dateGlobal = (ctx) => {
     methods(builtins, date, [
         ["now", 0, () => Date.now()],
         ["parse", 1, (_, args) => Date.parse(coerceToString(args[0]))],
-        ["UTC", 7, (_, args) => Date.UTC(...args.map((arg) => coerceToNumber(arg)))],
+        [
+            "UTC",
+            7,
+            (_, args) => Effect.map(Effect.forEach(args.slice(0, 7), (arg) => toPrimitiveNumber(ctx, arg), { concurrency: 1 }), (parts) => Date.UTC(...parts)),
+        ],
     ]);
     const self = (thisValue, name) => receiver(DateObj, thisValue, `Date.prototype.${name}`);
     const iso = (value) => {
@@ -107,6 +111,9 @@ export const dateGlobal = (ctx) => {
                 return Effect.map(Effect.forEach(args.slice(0, length), (arg) => toPrimitiveNumber(ctx, arg), {
                     concurrency: 1,
                 }), (values) => {
+                    // Every setter but setTime and setFullYear leaves an invalid Date untouched and answers NaN.
+                    if (Number.isNaN(hosted.getTime()) && name !== "setTime" && !name.endsWith("FullYear"))
+                        return NaN;
                     target.time = hosted[name](...values);
                     return target.time;
                 });

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

@@ -38,7 +38,7 @@ const parse = (ctx, args) => {
                     set(value, name, revived);
             }
         }
-        return yield* apply([key, value]);
+        return yield* apply([key, value], holder);
     });
     return visit(record(ctx.builtins.Object, { "": parsed }), "");
 };

package/dist/stdlib/math.js

@@ -2,23 +2,27 @@ import { Effect } from "effect";
 import { constants, methods } from "../interpreter/native.js";
 import { typeError } from "../interpreter/model.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 unary = (name, op) => [name, 1, (_, args) => op(coerceToNumber(args[0]))];
-const binary = (name, op) => [
-    name,
-    2,
-    (_, args) => op(coerceToNumber(args[0]), coerceToNumber(args[1])),
-];
-const variadic = (name, op) => [
-    name,
-    2,
-    (_, args) => op(...args.map(coerceToNumber)),
-];
+import { preserveConsumerError, withPrimitives } from "../interpreter/callback.js";
 export const mathGlobal = (ctx) => {
     const builtins = ctx.builtins;
     const math = new Obj(builtins.Object);
+    // Convert only the arguments a method consumes; like JS, extras are ignored
+    // (so built-ins work as callbacks receiving (element, index, array)).
+    const unary = (name, op) => [
+        name,
+        1,
+        (_, args) => withPrimitives(ctx, "number", [args[0]], ([a]) => op(coerceToNumber(a))),
+    ];
+    const binary = (name, op) => [
+        name,
+        2,
+        (_, args) => withPrimitives(ctx, "number", [args[0], args[1]], ([a, b]) => op(coerceToNumber(a), coerceToNumber(b))),
+    ];
+    const variadic = (name, op) => [
+        name,
+        2,
+        (_, args) => withPrimitives(ctx, "number", args, (values) => op(...values.map(coerceToNumber))),
+    ];
     constants(math, {
         PI: Math.PI,
         E: Math.E,

package/dist/stdlib/number.js

@@ -1,7 +1,8 @@
 import { constructor, constants, methods } from "../interpreter/native.js";
-import { coerceToNumber, coerceToString } from "../interpreter/objects.js";
+import { coerceToNumber } from "../interpreter/objects.js";
 import { rangeError, typeError } from "../interpreter/model.js";
-import { coercion } from "./value.js";
+import { withPrimitives } from "../interpreter/callback.js";
+import { coerce, coercion } from "./value.js";
 export const numberGlobal = (ctx) => {
     const builtins = ctx.builtins;
     const number = constructor(builtins, builtins.Number, {
@@ -24,46 +25,34 @@ export const numberGlobal = (ctx) => {
         ["isFinite", 1, (_, args) => Number.isFinite(args[0])],
         ["isNaN", 1, (_, args) => Number.isNaN(args[0])],
         ["isSafeInteger", 1, (_, args) => Number.isSafeInteger(args[0])],
-        [
-            "parseInt",
-            2,
-            (_, args) => {
-                return parseInt(coerceToString(args[0]), coerceToNumber(args[1]));
-            },
-        ],
-        ["parseFloat", 1, (_, args) => parseFloat(coerceToString(args[0]))],
+        ["parseInt", 2, (_, args) => coerce(ctx, "parseInt", args)],
+        ["parseFloat", 1, (_, args) => coerce(ctx, "parseFloat", args)],
     ]);
     const self = (thisValue, name) => {
         if (typeof thisValue === "number")
             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/object.js

@@ -1,7 +1,8 @@
 import { Effect } from "effect";
 import { constructor, methods, receiver } from "../interpreter/native.js";
-import { AsyncIteratorSymbol, invalidData, IteratorSymbol, rangeError, typeError, } from "../interpreter/model.js";
-import { define, entries, enumerableKeys, getOwn, hasOwn, hasPrototype, hidden, keys, own, Arr, Obj, PromiseObj, set, coerceToString, } from "../interpreter/objects.js";
+import { AsyncIteratorSymbol, invalidData, IteratorSymbol, typeError } from "../interpreter/model.js";
+import { define, entries, enumerableKeys, getOwn, hasOwn, hasPrototype, hidden, keys, own, ownKeys, Arr, Bytes, Obj, PromiseObj, set, coerceToString, } from "../interpreter/objects.js";
+import { primitivePrototype } from "../interpreter/intrinsics.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion } from "../interpreter/references.js";
 import { invoke, preserveConsumerError } from "../interpreter/callback.js";
 import { ToolReference } from "../tool-runtime.js";
@@ -37,8 +38,6 @@ export const objectAssign = (ctx, args) => {
         for (const key of enumerableKeys(from)) {
             rejectCircularInsertion(target, getOwn(from, key), "Object.assign result", seen);
             if (!set(target, key, getOwn(from, key))) {
-                if (target instanceof Arr && key === "length")
-                    throw rangeError("Invalid array length");
                 throw typeError(`Cannot assign to read only property '${String(key)}'.`);
             }
         }
@@ -81,6 +80,38 @@ const classTag = (value) => {
     return "Object";
 };
 const propertyKey = (value) => value === AsyncIteratorSymbol || value === IteratorSymbol ? value : coerceToString(value);
+// SetIntegrityLevel: primitives pass through. A typed array's bytes cannot carry attributes, so JS throws after
+// already making it non-extensible.
+const restrict = (level, value) => {
+    if (!(value instanceof Obj))
+        return value;
+    value.extensible = false;
+    if (level === "preventExtensions")
+        return value;
+    if (value instanceof Bytes && value.bytes.length > 0) {
+        throw typeError(`Cannot ${level} array buffer views with elements.`);
+    }
+    for (const slot of value.props.values()) {
+        slot.configurable = false;
+        if (level === "freeze" && "value" in slot)
+            slot.writable = false;
+    }
+    if (value instanceof Arr)
+        value.elements = { writable: level === "seal", enumerable: true, configurable: false };
+    return value;
+};
+// TestIntegrityLevel: array elements and `length` answer through `own`, so a non-extensible empty array is sealed
+// but not frozen, as in JS.
+const integrity = (value, frozen) => {
+    if (!(value instanceof Obj))
+        return true;
+    if (value.extensible)
+        return false;
+    return ownKeys(value).every((key) => {
+        const slot = own(value, key);
+        return slot !== undefined && !slot.configurable && !(frozen && "value" in slot && slot.writable);
+    });
+};
 // Object constructs identically with or without new, like JS. Only `keys` copies its result into the
 // program; `values`, `entries`, `assign`, and `fromEntries` hand back the program's own values.
 export const objectGlobal = (ctx) => {
@@ -118,18 +149,41 @@ export const objectGlobal = (ctx) => {
             (_, args) => new Arr(builtins.Array, entries(enumerableSource(ctx, "Object.entries(...)", args[0])).map((entry) => new Arr(builtins.Array, entry))),
         ],
         ["hasOwn", 2, (_, args) => hasOwn(enumerableSource(ctx, "Object.hasOwn(...)", args[0]), propertyKey(args[1]))],
+        ["is", 2, (_, args) => Object.is(args[0], args[1])],
+        ["assign", 2, (_, args) => objectAssign(ctx, args)],
+        ["fromEntries", 1, (_, args) => objectFromEntries(ctx, args[0])],
+        ["freeze", 1, (_, args) => restrict("freeze", args[0])],
+        ["seal", 1, (_, args) => restrict("seal", args[0])],
+        ["preventExtensions", 1, (_, args) => restrict("preventExtensions", args[0])],
+        ["isFrozen", 1, (_, args) => integrity(args[0], true)],
+        ["isSealed", 1, (_, args) => integrity(args[0], false)],
+        ["isExtensible", 1, (_, args) => args[0] instanceof Obj && args[0].extensible],
         [
-            "is",
+            "getPrototypeOf",
+            1,
+            (_, args) => {
+                if (args[0] instanceof Obj)
+                    return args[0].proto;
+                const proto = primitivePrototype(builtins, args[0]);
+                if (proto === undefined) {
+                    throw typeError(`Object.getPrototypeOf cannot convert ${describeValue(args[0])} to an object.`);
+                }
+                return proto;
+            },
+        ],
+        [
+            "create",
             2,
             (_, args) => {
-                if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
-                    throw invalidData("Object.is requires data values.");
+                if (args[0] !== null && !(args[0] instanceof Obj)) {
+                    throw typeError("Object prototype may only be an Object or null.");
+                }
+                if (args[1] !== undefined) {
+                    throw typeError("Object.create property descriptors are not supported; assign the fields after creating the object.");
                 }
-                return Object.is(args[0], args[1]);
+                return new Obj(args[0]);
             },
         ],
-        ["assign", 2, (_, args) => objectAssign(ctx, args)],
-        ["fromEntries", 1, (_, args) => objectFromEntries(ctx, args[0])],
     ]);
     define(object, "groupBy", groupBy(ctx, "Object"), hidden);
     methods(builtins, builtins.Object, [