poe-code 12.0.5 → 12.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "12.0.5",
+  "version": "12.0.6",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/safejs/dist/chunks/{chunk-RRSINVWT.js → chunk-KJSS53IH.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-XBRQ72W6.js";
+} from "./chunk-NDHGDM46.js";
 import {
   FsError,
   createFileSystem,
@@ -8181,4 +8181,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-RRSINVWT.js.map
+//# sourceMappingURL=chunk-KJSS53IH.js.map

package/packages/safejs/dist/chunks/{chunk-XBRQ72W6.js → chunk-NDHGDM46.js}

@@ -25137,6 +25137,67 @@ function callFunctionMethod(target, methodName, args, options, stack) {
   return options.callClosure(target, applyArgs, stack, thisValue);
 }
 
+// packages/safejs/src/interp/methods/collection-callback.ts
+var activeCallbacks = /* @__PURE__ */ new WeakMap();
+function enterKeyedCollectionCallback(target, keys, budget) {
+  let state = activeCallbacks.get(target);
+  if (state === void 0) {
+    state = { cursors: /* @__PURE__ */ new Set(), leaveRunning: enterRunningState(target) };
+    activeCallbacks.set(target, state);
+  }
+  const cursor = { budget, pending: /* @__PURE__ */ new Set() };
+  state.cursors.add(cursor);
+  const leave = () => {
+    if (!state.cursors.delete(cursor)) return;
+    cursor.pending.clear();
+    budget.setRetainedDataUsage(cursor, 0);
+    budget.setRetainedValues(cursor, void 0);
+    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: void 0 };
+    },
+    leave
+  };
+}
+function updateKeyedCollectionCallbacks(target, mutation, key) {
+  const state = activeCallbacks.get(target);
+  if (state === void 0) 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);
+  }
+}
+
 // packages/safejs/src/interp/methods/map.ts
 var mapMethodNames = /* @__PURE__ */ new Set([
   "get",
@@ -25171,34 +25232,40 @@ 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 void 0;
     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 void 0;
     }
@@ -25978,34 +26045,39 @@ 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 void 0;
     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 void 0;
     }
@@ -29676,4 +29748,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-XBRQ72W6.js.map
+//# sourceMappingURL=chunk-NDHGDM46.js.map