@opencode/codemode 2.0.16 → 2.0.17

package/dist/interpreter/objects.d.ts

@@ -84,6 +84,7 @@ export declare abstract class Opaque extends Obj {
     inspect(): string;
 }
 export declare abstract class Callable extends Opaque {
+    readonly length: number;
     readonly tag = "Function";
     constructor(proto: Obj, name: string, length: number);
     get describe(): string;
@@ -94,7 +95,17 @@ export declare class Fn extends Callable {
     readonly capturedScopes: Array<Map<string, Binding>>;
     readonly async: boolean;
     readonly generator: boolean;
-    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: Array<Map<string, Binding>>, async: boolean, generator: boolean);
+    /** Arrows have no `this` or `arguments` of their own; they read the enclosing function's. */
+    readonly arrow: boolean;
+    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: Array<Map<string, Binding>>, async: boolean, generator: boolean, 
+    /** Arrows have no `this` or `arguments` of their own; they read the enclosing function's. */
+    arrow: boolean);
+}
+/** The strict `arguments` object: an ordinary object with indexed own properties and a hidden `length`. */
+export declare class Arguments extends Obj {
+    readonly tag = "Arguments";
+    constructor(proto: Obj, args: Array<Value>);
+    iterator(): ArrayIterator<Value>;
 }
 export type NativeCall<R> = (thisValue: Value, args: Array<Value>) => Effect.Effect<Value, unknown, R>;
 export type NativeConstruct<R> = (args: Array<Value>, newTarget: Callable) => Effect.Effect<Value, unknown, R>;
@@ -181,6 +192,17 @@ export declare class SetObj extends Wrapper {
     toHost(item: (value: Value) => unknown): Set<unknown>;
     iterator(): SetIterator<Value>;
 }
+/** Keys are program objects, so a host WeakMap gives the same lifetime rule as JavaScript without any bookkeeping. */
+export declare class WeakMapObj extends Wrapper {
+    readonly tag = "WeakMap";
+    readonly map: WeakMap<Obj, Value>;
+    inspect(): string;
+}
+export declare class WeakSetObj extends Wrapper {
+    readonly tag = "WeakSet";
+    readonly set: WeakSet<Obj>;
+    inspect(): string;
+}
 export declare class URLSearchParamsObj extends Wrapper {
     readonly params: URLSearchParams;
     readonly tag = "URLSearchParams";

package/dist/interpreter/objects.js

@@ -112,9 +112,11 @@ export class Opaque extends Obj {
     }
 }
 export class Callable extends Opaque {
+    length;
     tag = "Function";
     constructor(proto, name, length) {
         super(proto);
+        this.length = length;
         define(this, "length", length, readonly);
         define(this, "name", name, readonly);
     }
@@ -128,7 +130,10 @@ export class Fn extends Callable {
     capturedScopes;
     async;
     generator;
-    constructor(proto, name, parameters, body, capturedScopes, async, generator) {
+    arrow;
+    constructor(proto, name, parameters, body, capturedScopes, async, generator, 
+    /** Arrows have no `this` or `arguments` of their own; they read the enclosing function's. */
+    arrow) {
         const optional = parameters.findIndex((p) => p.type === "AssignmentPattern" || p.type === "RestElement");
         super(proto, name, optional === -1 ? parameters.length : optional);
         this.parameters = parameters;
@@ -136,6 +141,21 @@ export class Fn extends Callable {
         this.capturedScopes = capturedScopes;
         this.async = async;
         this.generator = generator;
+        this.arrow = arrow;
+    }
+}
+/** The strict `arguments` object: an ordinary object with indexed own properties and a hidden `length`. */
+export class Arguments extends Obj {
+    tag = "Arguments";
+    constructor(proto, args) {
+        super(proto);
+        args.forEach((arg, index) => define(this, String(index), arg));
+        define(this, "length", args.length, hidden);
+    }
+    iterator() {
+        return keys(this)
+            .map((key) => get(this, key))
+            .values();
     }
 }
 export class Native extends Callable {
@@ -261,6 +281,21 @@ export class SetObj extends Wrapper {
         return this.set.values();
     }
 }
+/** Keys are program objects, so a host WeakMap gives the same lifetime rule as JavaScript without any bookkeeping. */
+export class WeakMapObj extends Wrapper {
+    tag = "WeakMap";
+    map = new WeakMap();
+    inspect() {
+        return "WeakMap { <items unknown> }";
+    }
+}
+export class WeakSetObj extends Wrapper {
+    tag = "WeakSet";
+    set = new WeakSet();
+    inspect() {
+        return "WeakSet { <items unknown> }";
+    }
+}
 export class URLSearchParamsObj extends Wrapper {
     params;
     tag = "URLSearchParams";

package/dist/stdlib/array.js

@@ -4,7 +4,7 @@ import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interp
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
 import { define, get, hidden, Arr, GeneratorObj, hostIterator, Obj, PromiseObj, coerceToInteger, coerceToNumber, coerceToString, rejectAddition, } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
-import { applyCollectionCallback, invoke, preserveConsumerError } from "../interpreter/callback.js";
+import { applyCollectionCallback, invoke, preserveConsumerError, withPrimitives } from "../interpreter/callback.js";
 import { compareText } from "../tool-runtime.js";
 const arrayLikeSource = (source) => {
     // JS would treat a promise as an empty array-like; that would hide a missing `await`.
@@ -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;
         }
     });
@@ -123,19 +125,19 @@ export const arrayGlobal = (ctx) => {
             "join",
             1,
             (thisValue, args) => {
-                const joined = self(thisValue, "join")
-                    .items.map((item) => coerceToString(item ?? ""))
-                    .join(args[0] === undefined ? "," : coerceToString(args[0]));
-                checkStringLength(joined.length);
-                return joined;
+                // .map would keep holes, which Effect.forEach would then hand to the body as undefined.
+                const parts = Array.from(self(thisValue, "join").items, (item) => item ?? "");
+                return withPrimitives(ctx, "string", [args[0] === undefined ? "," : args[0], ...parts], ([separator, ...items]) => {
+                    const joined = items.map(coerceToString).join(coerceToString(separator));
+                    checkStringLength(joined.length);
+                    return joined;
+                });
             },
         ],
         [
             "toString",
             0,
-            (thisValue) => self(thisValue, "toString")
-                .items.map((item) => coerceToString(item ?? ""))
-                .join(","),
+            (thisValue) => withPrimitives(ctx, "string", Array.from(self(thisValue, "toString").items, (item) => item ?? ""), (items) => items.map(coerceToString).join(",")),
         ],
         [
             "includes",
@@ -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.d.ts

@@ -3,3 +3,5 @@ import type { Interpreter } from "../interpreter/interpreter.js";
 export declare const groupBy: <R>(ctx: Interpreter<R>, namespace: "Map" | "Object") => import("../interpreter/objects.js").Native<R>;
 export declare const mapGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
 export declare const setGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+export declare const weakMapGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+export declare const weakSetGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

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;