@opencode/codemode 0.0.0-dev-20151 → 0.0.0-dev-20155

package/dist/interpreter/globals.js

@@ -2,7 +2,7 @@ import { Effect } from "effect";
 import { Arr, Callable, coerceToInteger, coerceToString, get, Obj } from "./objects.js";
 import { arrayGlobal } from "../stdlib/array.js";
 import { textDecoderGlobal, textEncoderGlobal, uint8ArrayGlobal } from "../stdlib/bytes.js";
-import { mapGlobal, setGlobal } from "../stdlib/collections.js";
+import { mapGlobal, setGlobal, weakMapGlobal, weakSetGlobal } from "../stdlib/collections.js";
 import { consoleGlobal } from "../stdlib/console.js";
 import { dateGlobal } from "../stdlib/date.js";
 import { jsonGlobal } from "../stdlib/json.js";
@@ -104,6 +104,8 @@ const table = {
     RegExp: (ctx) => regexpGlobal(ctx),
     Map: (ctx) => mapGlobal(ctx),
     Set: (ctx) => setGlobal(ctx),
+    WeakMap: (ctx) => weakMapGlobal(ctx),
+    WeakSet: (ctx) => weakSetGlobal(ctx),
     URL: (ctx) => urlGlobal(ctx),
     URLSearchParams: (ctx) => urlSearchParamsGlobal(ctx),
     Headers: (ctx) => headersGlobal(ctx),

package/dist/interpreter/intrinsics.d.ts

@@ -2,7 +2,7 @@ import { ErrorObj, Obj, type Value } from "./objects.js";
 export declare const errorTypes: readonly ["Error", "TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "AggregateError"];
 export type ErrorType = (typeof errorTypes)[number];
 export declare const isErrorType: (name: string) => name is ErrorType;
-declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "URL", "URLSearchParams", "Headers", "Uint8Array", "TextEncoder", "TextDecoder", "Promise", "Iterator", "IteratorHelper", "AsyncIterator", "Generator", "AsyncGenerator"];
+declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "WeakMap", "WeakSet", "URL", "URLSearchParams", "Headers", "Uint8Array", "TextEncoder", "TextDecoder", "Promise", "Iterator", "IteratorHelper", "AsyncIterator", "Generator", "AsyncGenerator"];
 /**
  * The built-in prototype objects of one runtime, allocated empty in dependency order. The globals populate them
  * and attach their constructors when the runtime is built.

package/dist/interpreter/intrinsics.js

@@ -22,6 +22,8 @@ const builtins = [
     "RegExp",
     "Map",
     "Set",
+    "WeakMap",
+    "WeakSet",
     "URL",
     "URLSearchParams",
     "Headers",
@@ -78,6 +80,8 @@ export const createBuiltins = () => {
         RegExp: plain(),
         Map: plain(),
         Set: plain(),
+        WeakMap: plain(),
+        WeakSet: plain(),
         URL: plain(),
         URLSearchParams: plain(),
         Headers: plain(),

package/dist/interpreter/objects.d.ts

@@ -192,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

@@ -281,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/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) => {
@@ -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/web.js

@@ -1,6 +1,6 @@
 import { fn, methods } from "../interpreter/native.js";
 import { typeError } from "../interpreter/model.js";
-import { define, entries, get, getOwn, hasOwn, hidden, isRuntimeReference, Arr, Bytes, DateObj, ErrorObj, MapObj, Obj, RegExpObj, SetObj, coerceToString, } from "../interpreter/objects.js";
+import { define, entries, get, getOwn, hasOwn, hidden, isRuntimeReference, Arr, Bytes, DateObj, ErrorObj, MapObj, Obj, RegExpObj, SetObj, WeakMapObj, WeakSetObj, coerceToString, } from "../interpreter/objects.js";
 import { createErrorValue, isErrorType } from "../interpreter/intrinsics.js";
 import { describeValue } from "../interpreter/references.js";
 import { ToolReference } from "../tool-runtime.js";
@@ -67,8 +67,9 @@ export const structuredCloneGlobal = (ctx) => fn(ctx.builtins, "structuredClone"
                 define(copy, "cause", clone(getOwn(value, "cause")), hidden);
             return copy;
         }
-        if (isRuntimeReference(value))
+        if (isRuntimeReference(value) || value instanceof WeakMapObj || value instanceof WeakSetObj) {
             throw typeError(`DataCloneError: ${describeValue(value)} could not be cloned.`);
+        }
         const copy = remember(value instanceof Arr ? new Arr(builtins.Array, new Array(value.items.length)) : new Obj(builtins.Object));
         for (const [key, item] of entries(value))
             define(copy, key, clone(item));

package/package.json

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