poe-code 11.0.4 → 11.0.5

package/package.json

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

package/packages/safejs/dist/chunks/{chunk-NBVIHENC.js → chunk-EWC7GLGM.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-CA342J7E.js";
+} from "./chunk-WC2N7PM5.js";
 
 // packages/safejs/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8048,4 +8048,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-NBVIHENC.js.map
+//# sourceMappingURL=chunk-EWC7GLGM.js.map

package/packages/safejs/dist/chunks/{chunk-CA342J7E.js → chunk-WC2N7PM5.js}

@@ -18514,12 +18514,10 @@ function getSandboxIterator(value) {
     return syncIterator(value[Symbol.iterator]());
   }
   if (isSandboxMap(value)) {
-    return syncIterator(
-      Array.from(value.entries, ([key, entry]) => [key, entry])[Symbol.iterator]()
-    );
+    return collectionIterator(value.entries);
   }
   if (isSandboxSet(value)) {
-    return syncIterator(value.values[Symbol.iterator]());
+    return collectionIterator(value.values);
   }
   if (typeof value !== "object" && typeof value !== "function" || value === null) {
     return void 0;
@@ -18530,6 +18528,29 @@ function getSandboxIterator(value) {
   }
   return syncIterator(Reflect.apply(iteratorMethod, value, []));
 }
+function collectionIterator(collection) {
+  let iterator = collection[Symbol.iterator]();
+  let exhausted = false;
+  return {
+    ...syncIterator({
+      next: () => {
+        if (exhausted) return { done: true, value: void 0 };
+        const result = iterator.next();
+        exhausted = result.done === true;
+        return result;
+      }
+    }),
+    snapshotIndex: () => {
+      if (exhausted) return collection.size;
+      let remaining = 0;
+      while (!iterator.next().done) remaining += 1;
+      const index = collection.size - remaining;
+      iterator = collection[Symbol.iterator]();
+      for (let skipped = 0; skipped < index; skipped += 1) iterator.next();
+      return index;
+    }
+  };
+}
 function generatorIterator(generator) {
   const invoke = async (method, value) => {
     const leaveRunning = enterRunningState(generator);
@@ -26221,19 +26242,35 @@ async function evaluateVariableDeclaration(node, context) {
     value: void 0
   };
 }
-function isRestorableBindingValue(value) {
-  if (Array.isArray(value)) {
-    return value.every(isRestorableBindingValue);
-  }
+function isRestorableBindingValue(value, seen = /* @__PURE__ */ new WeakSet()) {
   if (typeof value !== "object" || value === null) {
     return true;
   }
+  if (seen.has(value)) return true;
+  seen.add(value);
+  if (isSandboxMap(value)) {
+    for (const [key, entry] of value.entries) {
+      if (!isRestorableBindingValue(key, seen) || !isRestorableBindingValue(entry, seen)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (isSandboxSet(value)) {
+    for (const entry of value.values) {
+      if (!isRestorableBindingValue(entry, seen)) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every((entry) => isRestorableBindingValue(entry, seen));
+  }
   if (Object.hasOwn(value, "kind")) {
     return !["fn", "generator", "map", "promise", "regex", "set"].includes(
       String(value.kind)
     );
   }
-  return Object.values(value).every(isRestorableBindingValue);
+  return Object.values(value).every((entry) => isRestorableBindingValue(entry, seen));
 }
 function predeclareDeclarationBindings(node, scope) {
   for (const name of getDeclarationBindingNames2(node)) {
@@ -26447,13 +26484,24 @@ async function evaluateIfStatement(node, context) {
   return evaluateNode(branch, context);
 }
 async function evaluateForOfStatement(node, context) {
+  const restoredIteration = context.restoredLoopIterations.get(node.nodeId ?? -1);
+  let restoredEntry;
+  if (typeof restoredIteration === "object" && typeof restoredIteration.values[0] === "string") {
+    const restored = context.scope.consumeRestoredBinding(restoredIteration.values[0]);
+    if (restored.found && Array.isArray(restored.value)) {
+      restoredEntry = { done: false, value: restored.value[1] };
+      if (isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0])) {
+        return evaluateForOfIterator(node, restored.value[0], context, restoredEntry);
+      }
+    }
+  }
   const iterable = await evaluateNode(node.right, context);
   if (iterable.kind !== "normal") {
     return iterable;
   }
   const values = snapshotableIterationValues(iterable.value);
   if (values === void 0) {
-    return evaluateForOfIterator(node, iterable.value, context);
+    return evaluateForOfIterator(node, iterable.value, context, restoredEntry);
   }
   const restoredIndex = consumeRestoredLoopIterationIndex(node, context);
   for (let index = restoredIndex; index < values.length; index += 1) {
@@ -26489,7 +26537,7 @@ async function evaluateForOfStatement(node, context) {
     value: void 0
   };
 }
-async function evaluateForOfIterator(node, value, context) {
+async function evaluateForOfIterator(node, value, context, restoredEntry) {
   const iterator = getSandboxIterator(value);
   if (iterator === void 0) {
     throw new TypeError(`${String(value)} is not a supported iterable`);
@@ -26506,7 +26554,8 @@ async function evaluateForOfIterator(node, value, context) {
     }
   }
   while (true) {
-    const iteration = await iterator.next();
+    const iteration = restoredEntry ?? await iterator.next();
+    restoredEntry = void 0;
     if (typeof iteration !== "object" || iteration === null) {
       throw new TypeError("Iterator result must be an object.");
     }
@@ -26514,7 +26563,15 @@ async function evaluateForOfIterator(node, value, context) {
       context.activeLoopIterations.delete(nodeId);
       return normalEmptyResult();
     }
-    context.activeLoopIterations.set(nodeId, index);
+    context.activeLoopIterations.set(
+      nodeId,
+      iterator.snapshotIndex === void 0 ? index : {
+        get index() {
+          return iterator.snapshotIndex();
+        },
+        values: [value, iteration.value]
+      }
+    );
     const scope = context.scope.child();
     const binding = await bindForOfLoopVariable(node.left, iteration.value, scope, context);
     if (!binding.ok) {
@@ -26753,10 +26810,21 @@ function createLoopIterationContext(context, scope) {
   return {
     ...context,
     scope,
-    snapshot: (currentScope) => ({
-      ...currentScope.snapshot(),
-      ...context.activeLoopIterations.size === 0 ? {} : { loopIterations: Object.fromEntries(context.activeLoopIterations) }
-    })
+    snapshot: (currentScope) => {
+      const snapshot = currentScope.snapshot();
+      if (context.activeLoopIterations.size === 0) return snapshot;
+      snapshot.loopIterations = {};
+      for (const [nodeId, iteration] of context.activeLoopIterations) {
+        if (typeof iteration !== "number" && (isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]))) {
+          const bindingName = `#for-of:${nodeId}`;
+          snapshot.bindings[bindingName] = iteration.values;
+          snapshot.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
+        } else {
+          snapshot.loopIterations[nodeId] = iteration;
+        }
+      }
+      return snapshot;
+    }
   };
 }
 function consumeRestoredLoopIteration(node, context) {
@@ -26776,12 +26844,6 @@ function snapshotableIterationValues(value) {
   if (Array.isArray(value)) {
     return value;
   }
-  if (isSandboxMap(value)) {
-    return Array.from(value.entries, ([key, entry]) => [key, entry]);
-  }
-  if (isSandboxSet(value)) {
-    return Array.from(value.values);
-  }
   return void 0;
 }
 function isMatchingBreak(result, labels) {
@@ -28914,4 +28976,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-CA342J7E.js.map
+//# sourceMappingURL=chunk-WC2N7PM5.js.map