poe-code 13.0.2 → 13.0.3

package/packages/safe-js/dist/chunks/{chunk-JP474LP7.js → chunk-QCJ7UAMC.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-RIQRHKCB.js";
+} from "./chunk-73LWNNUG.js";
 import {
   createFileSystem,
   createNodeFileSystemAdapterRegistry,
@@ -8183,4 +8183,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-JP474LP7.js.map
+//# sourceMappingURL=chunk-QCJ7UAMC.js.map

package/packages/safe-js/dist/cli.js

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-JP474LP7.js";
+} from "./chunks/chunk-QCJ7UAMC.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-RIQRHKCB.js";
+} from "./chunks/chunk-73LWNNUG.js";
 import "./chunks/chunk-ZRX5HT5L.js";
 import "./chunks/chunk-WVN5MMDR.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/core.js

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

package/packages/safe-js/dist/index.js

@@ -29,7 +29,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-JP474LP7.js";
+} from "./chunks/chunk-QCJ7UAMC.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -51,7 +51,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-RIQRHKCB.js";
+} from "./chunks/chunk-73LWNNUG.js";
 import "./chunks/chunk-ZRX5HT5L.js";
 import "./chunks/chunk-WVN5MMDR.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/methods/array.js

@@ -1,5 +1,5 @@
 import { createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet } from "../values.js";
-import { assertCollectionMutable, enterCollectionCallback } from "../running-state.js";
+import { assertCollectionMutable, enterRunningState } from "../running-state.js";
 const activeArrayCallbacks = new WeakMap();
 const arrayMethodNames = new Set([
     "map",
@@ -76,7 +76,7 @@ export async function callArrayMethod(value, methodName, args, options, stack =
     if (isCallbackArrayMethod(methodName)) {
         let callbackState = activeArrayCallbacks.get(value);
         if (callbackState === undefined) {
-            callbackState = { depth: 0, leave: enterCollectionCallback(value) };
+            callbackState = { depth: 0, leave: enterRunningState(value) };
             activeArrayCallbacks.set(value, callbackState);
         }
         callbackState.depth += 1;
@@ -267,34 +267,57 @@ function getRequiredCallback(methodName, value) {
 async function mapArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     const result = new Array(length);
-    for (let index = 0; index < length; index += 1) {
-        if (!(index in value)) {
-            continue;
+    options.budget.setRetainedValues(result, () => [result]);
+    try {
+        for (let index = 0; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            result[index] = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
         }
-        result[index] = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
+        return result;
+    }
+    finally {
+        options.budget.setRetainedValues(result, undefined);
     }
-    return result;
 }
 async function filterArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     const result = [];
-    for (let index = 0; index < length; index += 1) {
-        if (!(index in value)) {
-            continue;
-        }
-        if (await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
-            result.push(value[index]);
+    options.budget.setRetainedValues(result, () => [result]);
+    try {
+        for (let index = 0; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            const entry = value[index];
+            if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+                result.push(entry);
+            }
         }
+        return result;
+    }
+    finally {
+        options.budget.setRetainedValues(result, undefined);
     }
-    return result;
 }
 async function findInArray(value, callback, options, stack, thisValue) {
-    const index = await findIndexInArray(value, callback, options, stack, thisValue);
-    return index < 0 ? undefined : value[index];
+    const length = value.length;
+    for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
+        const entry = index in value ? value[index] : undefined;
+        if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+            return entry;
+        }
+    }
+    return undefined;
 }
 async function findIndexInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
         const entry = index in value ? value[index] : undefined;
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return index;
@@ -305,6 +328,7 @@ async function findIndexInArray(value, callback, options, stack, thisValue) {
 async function findLastInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = length - 1; index >= 0; index -= 1) {
+        options.budget.visitNode();
         const entry = index in value ? value[index] : undefined;
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return entry;
@@ -315,6 +339,7 @@ async function findLastInArray(value, callback, options, stack, thisValue) {
 async function findLastIndexInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = length - 1; index >= 0; index -= 1) {
+        options.budget.visitNode();
         const entry = index in value ? value[index] : undefined;
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return index;
@@ -325,6 +350,7 @@ async function findLastIndexInArray(value, callback, options, stack, thisValue)
 async function someInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
         if (!(index in value)) {
             continue;
         }
@@ -337,6 +363,7 @@ async function someInArray(value, callback, options, stack, thisValue) {
 async function everyInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
         if (!(index in value)) {
             continue;
         }
@@ -348,10 +375,10 @@ async function everyInArray(value, callback, options, stack, thisValue) {
 }
 async function reduceArray(value, callback, hasInitialValue, initialValue, options, stack) {
     const length = value.length;
-    const start = findNextDefinedIndex(value, 0, 1, length);
     if (hasInitialValue) {
-        return reduceFromLeft(value, callback, initialValue, start, length, options, stack);
+        return reduceFromLeft(value, callback, initialValue, 0, length, options, stack);
     }
+    const start = findNextDefinedIndex(value, 0, 1, length, options.budget);
     if (start < 0) {
         throw new TypeError("Reduce of empty array with no initial value.");
     }
@@ -359,10 +386,10 @@ async function reduceArray(value, callback, hasInitialValue, initialValue, optio
 }
 async function reduceRightArray(value, callback, hasInitialValue, initialValue, options, stack) {
     const length = value.length;
-    const start = findNextDefinedIndex(value, length - 1, -1, length);
     if (hasInitialValue) {
-        return reduceFromRight(value, callback, initialValue, start, length, options, stack);
+        return reduceFromRight(value, callback, initialValue, length - 1, length, options, stack);
     }
+    const start = findNextDefinedIndex(value, length - 1, -1, length, options.budget);
     if (start < 0) {
         throw new TypeError("Reduce of empty array with no initial value.");
     }
@@ -370,27 +397,44 @@ async function reduceRightArray(value, callback, hasInitialValue, initialValue,
 }
 async function reduceFromLeft(value, callback, accumulator, startIndex, length, options, stack) {
     let current = accumulator;
-    for (let index = startIndex; index < length; index += 1) {
-        if (!(index in value)) {
-            continue;
+    const retainedAccumulator = {};
+    options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+    try {
+        for (let index = startIndex; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            current = await options.callClosure(callback, [current, value[index], index, value], stack);
         }
-        current = await options.callClosure(callback, [current, value[index], index, value], stack);
+        return current;
+    }
+    finally {
+        options.budget.setRetainedValues(retainedAccumulator, undefined);
     }
-    return current;
 }
 async function reduceFromRight(value, callback, accumulator, startIndex, length, options, stack) {
     let current = accumulator;
-    for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
-        if (!(index in value)) {
-            continue;
+    const retainedAccumulator = {};
+    options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+    try {
+        for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            current = await options.callClosure(callback, [current, value[index], index, value], stack);
         }
-        current = await options.callClosure(callback, [current, value[index], index, value], stack);
+        return current;
+    }
+    finally {
+        options.budget.setRetainedValues(retainedAccumulator, undefined);
     }
-    return current;
 }
 async function forEachArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
         if (!(index in value)) {
             continue;
         }
@@ -400,25 +444,33 @@ async function forEachArray(value, callback, options, stack, thisValue) {
 async function flatMapArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     const result = [];
-    for (let index = 0; index < length; index += 1) {
-        if (!(index in value)) {
-            continue;
-        }
-        const mapped = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
-        if (Array.isArray(mapped)) {
-            for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
-                if (!(mappedIndex in mapped)) {
-                    continue;
+    options.budget.setRetainedValues(result, () => [result]);
+    try {
+        for (let index = 0; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            const mapped = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
+            if (Array.isArray(mapped)) {
+                for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
+                    options.budget.visitNode();
+                    if (!(mappedIndex in mapped)) {
+                        continue;
+                    }
+                    result.push(mapped[mappedIndex]);
+                    options.budget.allocateArrayLength(result.length);
                 }
-                result.push(mapped[mappedIndex]);
-                options.budget.allocateArrayLength(result.length);
+                continue;
             }
-            continue;
+            result.push(mapped);
+            options.budget.allocateArrayLength(result.length);
         }
-        result.push(mapped);
-        options.budget.allocateArrayLength(result.length);
+        return result;
+    }
+    finally {
+        options.budget.setRetainedValues(result, undefined);
     }
-    return result;
 }
 function flattenArray(value, depth, budget) {
     const result = [];
@@ -440,48 +492,61 @@ function appendFlattenedEntries(value, depth, result, budget) {
     }
 }
 async function sortArray(value, comparator, options, stack) {
+    const length = value.length;
     const definedValues = [];
     let undefinedCount = 0;
-    for (let index = 0; index < value.length; index += 1) {
-        if (!(index in value)) {
-            continue;
+    let currentEntry;
+    options.budget.setRetainedValues(definedValues, () => [definedValues, currentEntry]);
+    try {
+        for (let index = 0; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            const entry = value[index];
+            if (entry === undefined) {
+                undefinedCount += 1;
+                continue;
+            }
+            definedValues.push(entry);
+        }
+        for (let index = 1; index < definedValues.length; index += 1) {
+            currentEntry = definedValues[index];
+            let cursor = index - 1;
+            while (cursor >= 0 &&
+                (await compareEntries(definedValues[cursor], currentEntry, comparator, options, stack)) > 0) {
+                definedValues[cursor + 1] = definedValues[cursor];
+                cursor -= 1;
+            }
+            definedValues[cursor + 1] = currentEntry;
         }
-        const entry = value[index];
-        if (entry === undefined) {
-            undefinedCount += 1;
-            continue;
+        currentEntry = undefined;
+        for (let index = 0; index < definedValues.length; index += 1) {
+            value[index] = definedValues[index];
         }
-        definedValues.push(entry);
-    }
-    for (let index = 1; index < definedValues.length; index += 1) {
-        const entry = definedValues[index];
-        let cursor = index - 1;
-        while (cursor >= 0 &&
-            (await compareEntries(definedValues[cursor], entry, comparator, options, stack)) > 0) {
-            definedValues[cursor + 1] = definedValues[cursor];
-            cursor -= 1;
+        for (let index = 0; index < undefinedCount; index += 1) {
+            value[definedValues.length + index] = undefined;
+        }
+        for (let index = definedValues.length + undefinedCount; index < length; index += 1) {
+            options.budget.visitNode();
+            delete value[index];
         }
-        definedValues[cursor + 1] = entry;
-    }
-    for (let index = 0; index < definedValues.length; index += 1) {
-        value[index] = definedValues[index];
-    }
-    for (let index = 0; index < undefinedCount; index += 1) {
-        value[definedValues.length + index] = undefined;
     }
-    for (let index = definedValues.length + undefinedCount; index < value.length; index += 1) {
-        delete value[index];
+    finally {
+        options.budget.setRetainedValues(definedValues, undefined);
     }
 }
 async function compareEntries(left, right, comparator, options, stack) {
+    options.budget.visitNode();
     const result = Number(await options.callClosure(comparator, [left, right], stack));
     return Number.isNaN(result) ? 0 : result;
 }
 async function callArrayCallback(callback, value, index, array, options, stack, thisValue) {
     return options.callClosure(callback, [value, index, array], stack, thisValue);
 }
-function findNextDefinedIndex(value, startIndex, direction, length) {
+function findNextDefinedIndex(value, startIndex, direction, length, budget) {
     for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
+        budget.visitNode();
         if (index in value) {
             return index;
         }