poe-code 12.0.5 → 12.0.6

package/packages/safejs/dist/cli.js

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-RRSINVWT.js";
+} from "./chunks/chunk-KJSS53IH.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-XBRQ72W6.js";
+} from "./chunks/chunk-NDHGDM46.js";
 import "./chunks/chunk-B3G3JVCW.js";
 import "./chunks/chunk-4YIDX44G.js";
 

package/packages/safejs/dist/core.js

@@ -3,7 +3,7 @@ import {
   createReplayableRandom,
   lint,
   run
-} from "./chunks/chunk-XBRQ72W6.js";
+} from "./chunks/chunk-NDHGDM46.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safejs/dist/index.js

@@ -29,7 +29,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-RRSINVWT.js";
+} from "./chunks/chunk-KJSS53IH.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -51,7 +51,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-XBRQ72W6.js";
+} from "./chunks/chunk-NDHGDM46.js";
 import "./chunks/chunk-B3G3JVCW.js";
 import "./chunks/chunk-4YIDX44G.js";
 

package/packages/safejs/dist/interp/methods/collection-callback.d.ts

@@ -0,0 +1,7 @@
+import type { Budget } from "../budget.js";
+import type { SandboxValue } from "../values.js";
+export declare function enterKeyedCollectionCallback(target: object, keys: Iterable<SandboxValue>, budget: Budget): {
+    next(): IteratorResult<SandboxValue>;
+    leave(): void;
+};
+export declare function updateKeyedCollectionCallbacks(target: object, mutation: "add" | "delete" | "clear", key?: SandboxValue): void;

package/packages/safejs/dist/interp/methods/collection-callback.js

@@ -0,0 +1,68 @@
+import { enterRunningState } from "../running-state.js";
+const activeCallbacks = new WeakMap();
+export function enterKeyedCollectionCallback(target, keys, budget) {
+    let state = activeCallbacks.get(target);
+    if (state === undefined) {
+        state = { cursors: new Set(), leaveRunning: enterRunningState(target) };
+        activeCallbacks.set(target, state);
+    }
+    const cursor = { budget, pending: new Set() };
+    state.cursors.add(cursor);
+    const leave = () => {
+        if (!state.cursors.delete(cursor))
+            return;
+        cursor.pending.clear();
+        budget.setRetainedDataUsage(cursor, 0);
+        budget.setRetainedValues(cursor, undefined);
+        if (state.cursors.size === 0) {
+            activeCallbacks.delete(target);
+            state.leaveRunning();
+        }
+    };
+    try {
+        budget.setRetainedDataUsage(cursor, 1);
+        budget.setRetainedValues(cursor, () => cursor.pending);
+        for (const key of keys)
+            updatePendingKeys(cursor, "add", key);
+    }
+    catch (error) {
+        leave();
+        throw error;
+    }
+    return {
+        next: () => {
+            budget.visitNode();
+            for (const key of cursor.pending) {
+                cursor.pending.delete(key);
+                budget.setRetainedDataUsage(cursor, 1 + cursor.pending.size);
+                return { done: false, value: key };
+            }
+            return { done: true, value: undefined };
+        },
+        leave
+    };
+}
+export function updateKeyedCollectionCallbacks(target, mutation, key) {
+    const state = activeCallbacks.get(target);
+    if (state === undefined)
+        return;
+    for (const cursor of state.cursors)
+        updatePendingKeys(cursor, mutation, key);
+}
+function updatePendingKeys(cursor, mutation, key) {
+    const { budget, pending } = cursor;
+    budget.visitNode();
+    if (mutation === "add") {
+        const nextSize = pending.has(key) ? pending.size : pending.size + 1;
+        budget.allocateCollectionEntries(nextSize);
+        budget.setRetainedDataUsage(cursor, 1 + nextSize);
+        pending.add(key);
+    }
+    else {
+        if (mutation === "delete")
+            pending.delete(key);
+        else
+            pending.clear();
+        budget.setRetainedDataUsage(cursor, 1 + pending.size);
+    }
+}

package/packages/safejs/dist/interp/methods/map.js

@@ -1,5 +1,6 @@
 import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure } from "../values.js";
-import { assertCollectionMutable, enterCollectionCallback } from "../running-state.js";
+import { assertCollectionMutable } from "../running-state.js";
+import { enterKeyedCollectionCallback, updateKeyedCollectionCallbacks } from "./collection-callback.js";
 const mapMethodNames = new Set([
     "get",
     "set",
@@ -33,35 +34,43 @@ export async function callMapMethod(target, methodName, args, options, stack = [
             return target.entries.get(args[0]);
         case "set": {
             assertCollectionMutable(target);
-            const nextSize = target.entries.has(args[0]) ? target.entries.size : target.entries.size + 1;
+            const exists = target.entries.has(args[0]);
+            const nextSize = exists ? target.entries.size : target.entries.size + 1;
             options.budget.allocateCollectionEntries(nextSize);
+            if (!exists)
+                updateKeyedCollectionCallbacks(target, "add", args[0]);
             target.entries.set(args[0], args[1]);
             return target;
         }
         case "has":
             return target.entries.has(args[0]);
-        case "delete":
+        case "delete": {
             assertCollectionMutable(target);
-            return target.entries.delete(args[0]);
+            const deleted = target.entries.delete(args[0]);
+            if (deleted)
+                updateKeyedCollectionCallbacks(target, "delete", args[0]);
+            return deleted;
+        }
         case "clear":
             assertCollectionMutable(target);
             target.entries.clear();
+            updateKeyedCollectionCallbacks(target, "clear");
             return undefined;
         case "forEach": {
             const callback = args[0];
             if (!isSandboxClosure(callback)) {
                 throw new TypeError("Map.prototype.forEach requires a callback function.");
             }
-            const leaveCallback = enterCollectionCallback(target);
+            const cursor = enterKeyedCollectionCallback(target, target.entries.keys(), options.budget);
             try {
-                const entries = [...target.entries];
-                for (let index = 0; index < entries.length; index += 1) {
-                    const [key, value] = entries[index];
+                for (let entry = cursor.next(); !entry.done; entry = cursor.next()) {
+                    const key = entry.value;
+                    const value = target.entries.get(key);
                     await options.callClosure(callback, [value, key, target], stack, args[1]);
                 }
             }
             finally {
-                leaveCallback();
+                cursor.leave();
             }
             return undefined;
         }

package/packages/safejs/dist/interp/methods/set.js

@@ -1,5 +1,6 @@
 import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure } from "../values.js";
-import { assertCollectionMutable, enterCollectionCallback } from "../running-state.js";
+import { assertCollectionMutable } from "../running-state.js";
+import { enterKeyedCollectionCallback, updateKeyedCollectionCallbacks } from "./collection-callback.js";
 const setMethodNames = new Set([
     "add",
     "has",
@@ -30,35 +31,42 @@ export async function callSetMethod(target, methodName, args, options, stack = [
     switch (methodName) {
         case "add": {
             assertCollectionMutable(target);
-            const nextSize = target.values.has(args[0]) ? target.values.size : target.values.size + 1;
+            const exists = target.values.has(args[0]);
+            const nextSize = exists ? target.values.size : target.values.size + 1;
             options.budget.allocateCollectionEntries(nextSize);
+            if (!exists)
+                updateKeyedCollectionCallbacks(target, "add", args[0]);
             target.values.add(args[0]);
             return target;
         }
         case "has":
             return target.values.has(args[0]);
-        case "delete":
+        case "delete": {
             assertCollectionMutable(target);
-            return target.values.delete(args[0]);
+            const deleted = target.values.delete(args[0]);
+            if (deleted)
+                updateKeyedCollectionCallbacks(target, "delete", args[0]);
+            return deleted;
+        }
         case "clear":
             assertCollectionMutable(target);
             target.values.clear();
+            updateKeyedCollectionCallbacks(target, "clear");
             return undefined;
         case "forEach": {
             const callback = args[0];
             if (!isSandboxClosure(callback)) {
                 throw new TypeError("Set.prototype.forEach requires a callback function.");
             }
-            const leaveCallback = enterCollectionCallback(target);
+            const cursor = enterKeyedCollectionCallback(target, target.values, options.budget);
             try {
-                const values = [...target.values];
-                for (let index = 0; index < values.length; index += 1) {
-                    const value = values[index];
+                for (let entry = cursor.next(); !entry.done; entry = cursor.next()) {
+                    const value = entry.value;
                     await options.callClosure(callback, [value, value, target], stack, args[1]);
                 }
             }
             finally {
-                leaveCallback();
+                cursor.leave();
             }
             return undefined;
         }