poe-code 11.0.4 → 11.0.6

package/packages/safejs/dist/cli.js

@@ -19,7 +19,7 @@ import {
   parseMcpConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-NBVIHENC.js";
+} from "./chunks/chunk-NP42RTIU.js";
 import {
   Budget,
   SandboxError,
@@ -31,7 +31,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-CA342J7E.js";
+} from "./chunks/chunk-OPNWSDXC.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/cli.ts

package/packages/safejs/dist/core.js

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

package/packages/safejs/dist/index.js

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-NBVIHENC.js";
+} from "./chunks/chunk-NP42RTIU.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -48,7 +48,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-CA342J7E.js";
+} from "./chunks/chunk-OPNWSDXC.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/runner/run-harness.ts

package/packages/safejs/dist/interp/interpreter.js

@@ -667,17 +667,35 @@ async function evaluateVariableDeclaration(node, context) {
         value: undefined
     };
 }
-function isRestorableBindingValue(value) {
-    if (Array.isArray(value)) {
-        return value.every(isRestorableBindingValue);
-    }
+function isRestorableBindingValue(value, seen = 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 getDeclarationBindingNames(node)) {
@@ -893,13 +911,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 === undefined) {
-        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) {
@@ -935,7 +964,7 @@ async function evaluateForOfStatement(node, context) {
         value: undefined
     };
 }
-async function evaluateForOfIterator(node, value, context) {
+async function evaluateForOfIterator(node, value, context, restoredEntry) {
     const iterator = getSandboxIterator(value);
     if (iterator === undefined) {
         throw new TypeError(`${String(value)} is not a supported iterable`);
@@ -952,7 +981,8 @@ async function evaluateForOfIterator(node, value, context) {
         }
     }
     while (true) {
-        const iteration = await iterator.next();
+        const iteration = restoredEntry ?? (await iterator.next());
+        restoredEntry = undefined;
         if (typeof iteration !== "object" || iteration === null) {
             throw new TypeError("Iterator result must be an object.");
         }
@@ -960,7 +990,14 @@ async function evaluateForOfIterator(node, value, context) {
             context.activeLoopIterations.delete(nodeId);
             return normalEmptyResult();
         }
-        context.activeLoopIterations.set(nodeId, index);
+        context.activeLoopIterations.set(nodeId, iterator.snapshotIndex === undefined
+            ? 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) {
@@ -1203,12 +1240,24 @@ 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) {
@@ -1228,12 +1277,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 undefined;
 }
 function isMatchingBreak(result, labels) {

package/packages/safejs/dist/interp/iteration.d.ts

@@ -1,6 +1,7 @@
 import { type SandboxValue } from "./values.js";
 export type SandboxIterator = {
     readonly generator?: true;
+    snapshotIndex?(): number;
     next(value?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
     return?(value?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
     throw?(error?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;

package/packages/safejs/dist/interp/iteration.js

@@ -8,10 +8,10 @@ export 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 undefined;
@@ -22,6 +22,33 @@ export 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: undefined };
+                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);

package/packages/safejs/dist/parse/parser.js

@@ -759,7 +759,13 @@ class Parser {
                 }
             ];
         }
-        this.expectKeyword("from");
+        const fromToken = this.currentToken();
+        if (fromToken.type !== "identifier" ||
+            fromToken.value !== "from" ||
+            fromToken.end.offset - fromToken.start.offset !== fromToken.value.length) {
+            throw new Error(`Expected 'from' at line ${fromToken.start.line}, column ${fromToken.start.column}.`);
+        }
+        this.index += 1;
         const sourceToken = this.currentToken();
         if (sourceToken.type !== "string") {
             throw unexpectedTokenError(sourceToken);

package/packages/safejs/dist/parse/tokenizer.js

@@ -18,7 +18,6 @@ const KEYWORDS = new Set([
     "await",
     "yield",
     "import",
-    "from",
     "as",
     "true",
     "false",