poe-code 14.0.51 → 14.0.52

package/packages/safe-js/dist/chunks/{chunk-MQU3AETK.js → chunk-XIBH4BH2.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-7AIY5C3F.js";
+} from "./chunk-DVWTNFTV.js";
 import {
   createFileSystem,
   createNodeFileSystemAdapterRegistry,
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-MQU3AETK.js.map
+//# sourceMappingURL=chunk-XIBH4BH2.js.map

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-MQU3AETK.js";
+} from "./chunks/chunk-XIBH4BH2.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-7AIY5C3F.js";
+} from "./chunks/chunk-DVWTNFTV.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-7AIY5C3F.js";
+} from "./chunks/chunk-DVWTNFTV.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safe-js/dist/graph-depth.js

@@ -1,6 +1,8 @@
 import { replaceErrorStack } from "./error/shape.js";
 import { SandboxError } from "./interp/budget.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "./interp/arguments.js";
+import { collectionIteratorState, isSandboxCollectionIterator } from "./interp/collection-iterator.js";
+import { isSandboxMap, isSandboxSet } from "./interp/collection-brands.js";
 export const MAX_DATA_DEPTH = 1_024;
 export class SnapshotBudgetError extends Error {
     code = "budgetExceeded";
@@ -64,16 +66,20 @@ function graphEntries(value) {
     if (isSandboxArguments(value)) {
         return getSandboxArgumentEntries(value).map(([key, entry]) => [`.${key}`, entry]);
     }
-    if (value instanceof Map) {
-        return [...value.entries()].flatMap(([key, entry], index) => [
+    const map = isSandboxMap(value) ? value.entries : value instanceof Map ? value : undefined;
+    if (map !== undefined) {
+        return [...map.entries()].flatMap(([key, entry], index) => [
             [`.<map>[${index}].key`, key],
             [`.<map>[${index}].value`, entry]
         ]);
     }
-    if (value instanceof Set) {
-        return [...value.values()].map((entry, index) => [`.<set>[${index}]`, entry]);
+    const set = isSandboxSet(value) ? value.values : value instanceof Set ? value : undefined;
+    if (set !== undefined) {
+        return [...set.values()].map((entry, index) => [`.<set>[${index}]`, entry]);
     }
     const entries = [];
+    if (isSandboxCollectionIterator(value))
+        entries.push([".<collection>", collectionIteratorState(value).collection]);
     for (const key of Object.keys(value)) {
         const descriptor = Object.getOwnPropertyDescriptor(value, key);
         if (descriptor !== undefined && "value" in descriptor)

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

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-MQU3AETK.js";
+} from "./chunks/chunk-XIBH4BH2.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-7AIY5C3F.js";
+} from "./chunks/chunk-DVWTNFTV.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/cancel.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { collectionIteratorState, isSandboxCollectionIterator } from "./collection-iterator.js";
 import { getSandboxPrototype } from "./object-model.js";
 import { createSandboxPromise, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet } from "./values.js";
 import { assertPromiseExecutionAllowed, interruptOnFatalPromiseRejection, onFatalPromiseRejection, observeSandboxPromise, trackSandboxPromise } from "./promise-tracker.js";
@@ -97,6 +98,8 @@ function registerCancelablePromises(value, signal) {
                 pending.push(entry);
         }
         else {
+            if (isSandboxCollectionIterator(current))
+                pending.push(collectionIteratorState(current).collection);
             for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(current))) {
                 if ("value" in descriptor)
                     pending.push(descriptor.value);

package/packages/safe-js/dist/interp/collection-brands.d.ts

@@ -0,0 +1,5 @@
+import type { SandboxMap, SandboxSet } from "./values.js";
+export declare const sandboxMapBrand: unique symbol;
+export declare const sandboxSetBrand: unique symbol;
+export declare function isSandboxMap(value: unknown): value is SandboxMap;
+export declare function isSandboxSet(value: unknown): value is SandboxSet;

package/packages/safe-js/dist/interp/collection-brands.js

@@ -0,0 +1,8 @@
+export const sandboxMapBrand = Symbol("SandboxMap");
+export const sandboxSetBrand = Symbol("SandboxSet");
+export function isSandboxMap(value) {
+    return typeof value === "object" && value !== null && sandboxMapBrand in value;
+}
+export function isSandboxSet(value) {
+    return typeof value === "object" && value !== null && sandboxSetBrand in value;
+}

package/packages/safe-js/dist/interp/collection-iterator.d.ts

@@ -0,0 +1,27 @@
+import type { Budget } from "./budget.js";
+import type { SandboxMap, SandboxSet, SandboxValue } from "./values.js";
+declare const collectionIteratorBrand: unique symbol;
+export type SandboxCollectionIterator = {
+    readonly [collectionIteratorBrand]: true;
+};
+export type CollectionIterationMethod = "keys" | "values" | "entries";
+export type CollectionIteratorSnapshot = {
+    collection: SandboxMap | SandboxSet | undefined;
+    collectionKind: "map" | "set";
+    method: CollectionIterationMethod;
+    index: number;
+    exhausted: boolean;
+};
+type IteratorState = Omit<CollectionIteratorSnapshot, "index"> & {
+    iterator: Iterator<SandboxValue> | undefined;
+};
+export declare function isSandboxCollectionIterator(value: unknown): value is SandboxCollectionIterator;
+export declare function createSandboxCollectionIterator(collection: SandboxMap | SandboxSet, method: CollectionIterationMethod): SandboxCollectionIterator;
+export declare function restoreSandboxCollectionIterator(snapshot: CollectionIteratorSnapshot, target?: SandboxCollectionIterator): SandboxCollectionIterator;
+export declare function collectionIteratorState(value: SandboxCollectionIterator): Readonly<IteratorState>;
+export declare function snapshotCollectionIterator(value: SandboxCollectionIterator): CollectionIteratorSnapshot;
+export declare function nextCollectionIterator(value: SandboxCollectionIterator, budget?: Budget): {
+    value: SandboxValue;
+    done: boolean;
+};
+export {};

package/packages/safe-js/dist/interp/collection-iterator.js

@@ -0,0 +1,61 @@
+const states = new WeakMap();
+export function isSandboxCollectionIterator(value) {
+    return typeof value === "object" && value !== null && states.has(value);
+}
+export function createSandboxCollectionIterator(collection, method) {
+    return restoreSandboxCollectionIterator({ collection, collectionKind: collection.kind, method, index: 0, exhausted: false });
+}
+// A registered placeholder lets snapshot readers resolve collection/iterator cycles.
+// Initialize its cursor only after the source collection has been fully restored.
+export function restoreSandboxCollectionIterator(snapshot, target = Object.create(null)) {
+    const { collection, collectionKind, method, index, exhausted } = snapshot;
+    if (collection !== undefined && collection.kind !== collectionKind)
+        throw new TypeError("Collection iterator source has the wrong brand.");
+    if (!exhausted && collection === undefined)
+        throw new TypeError("Live collection iterator requires its source collection.");
+    const iterator = exhausted ? undefined : nativeIterator(collection, method);
+    for (let skipped = 0; skipped < index; skipped += 1) {
+        if (iterator === undefined || iterator.next().done)
+            throw new TypeError("Collection iterator cursor exceeds its source.");
+    }
+    states.set(target, { collection: exhausted ? undefined : collection, collectionKind, method, exhausted, iterator });
+    return target;
+}
+export function collectionIteratorState(value) {
+    const state = states.get(value);
+    if (state === undefined)
+        throw new TypeError("Expected a collection iterator.");
+    return state;
+}
+export function snapshotCollectionIterator(value) {
+    const state = collectionIteratorState(value);
+    if (state.exhausted)
+        return { ...state, index: 0 };
+    const collection = state.collection;
+    const size = collection.kind === "map" ? collection.entries.size : collection.values.size;
+    let remaining = 0;
+    while (!state.iterator.next().done)
+        remaining += 1;
+    const snapshot = { ...state, index: size - remaining };
+    restoreSandboxCollectionIterator(snapshot, value);
+    return snapshot;
+}
+export function nextCollectionIterator(value, budget) {
+    const state = states.get(value);
+    budget?.visitNode();
+    if (state.exhausted)
+        return { value: undefined, done: true };
+    const result = state.iterator.next();
+    if (result.done) {
+        state.exhausted = true;
+        state.collection = undefined;
+        state.iterator = undefined;
+        return { value: undefined, done: true };
+    }
+    if (state.method === "entries")
+        budget?.allocateArrayLength(2);
+    return { value: result.value, done: false };
+}
+function nativeIterator(collection, method) {
+    return collection.kind === "map" ? collection.entries[method]() : collection.values[method]();
+}

package/packages/safe-js/dist/interp/globals/collections.js

@@ -71,7 +71,7 @@ function populateCollection(source, collection, { name, budget, context, append,
     budget.allocateCollectionEntries(0);
     if (source === undefined || source === null)
         return collection;
-    const iterator = getSandboxIterator(source);
+    const iterator = getSandboxIterator(source, budget);
     if (iterator === undefined)
         throw new TypeError(`${name} constructor requires an iterable.`);
     let entry;

package/packages/safe-js/dist/interp/globals/misc.js

@@ -1,3 +1,4 @@
+import { isSandboxCollectionIterator } from "../collection-iterator.js";
 import { assertSandboxGraphDepth } from "../../graph-depth.js";
 import { allocateProducedSandboxValue, cloneSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet } from "../values.js";
 export function createMiscGlobals(options) {
@@ -36,8 +37,8 @@ function structuredCloneSandboxValue(value, budget) {
     return allocateProducedSandboxValue(clone, budget);
 }
 function assertStructuredCloneable(value, seen) {
-    if (isSandboxClosure(value) || isSandboxPromise(value)) {
-        throw new TypeError("structuredClone() cannot clone closures or promises.");
+    if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value)) {
+        throw new TypeError("structuredClone() cannot clone closures, promises, or collection iterators.");
     }
     if (typeof value !== "object" || value === null || seen.has(value)) {
         return;

package/packages/safe-js/dist/interp/globals/object-array.js

@@ -122,7 +122,7 @@ export function createObjectArrayGlobals(options) {
             fromEntries: createSandboxClosure({
                 sandbox: true,
                 call: ([value], context) => {
-                    const iterator = getSandboxIterator(value);
+                    const iterator = getSandboxIterator(value, options.budget);
                     if (iterator === undefined) {
                         throw new TypeError("Object.fromEntries requires an iterable.");
                     }
@@ -411,7 +411,7 @@ async function arrayFromSandboxValues(args, budget, context) {
     const read = (property) => context?.getProperty !== undefined
         ? context.getProperty(items, property)
         : getSandboxDataProperty(items, property, budget);
-    const iterator = getSandboxIterator(items);
+    const iterator = getSandboxIterator(items, budget);
     const constructor = context?.thisValue;
     let result;
     let currentValue;

package/packages/safe-js/dist/interp/globals/object.js

@@ -3,6 +3,7 @@ import { isSandboxDate } from "../date.js";
 import { isSandboxErrorConstructorInstance } from "../exceptions.js";
 import { isFloat32Array } from "../float32.js";
 import { hasHostObjectMember, isGuestHostObject } from "../host-capabilities.js";
+import { collectionIteratorState, isSandboxCollectionIterator } from "../collection-iterator.js";
 import { getSandboxPrototype, installObjectPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties } from "../object-model.js";
 import { sandboxString } from "../string-coercion.js";
 import { createSandboxClosure, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet } from "../values.js";
@@ -143,6 +144,8 @@ function typeTag(value) {
         return "Map";
     if (isSandboxSet(value))
         return "Set";
+    if (isSandboxCollectionIterator(value))
+        return collectionIteratorState(value).collectionKind === "map" ? "Map Iterator" : "Set Iterator";
     if (isSandboxPromise(value))
         return "Promise";
     if (isSandboxGenerator(value))

package/packages/safe-js/dist/interp/interpreter.js

@@ -27,6 +27,8 @@ import { callSetMethod, getSetMember, isSetMethodName } from "./methods/set.js";
 import { isSandboxErrorConstructorInstance } from "./globals/error.js";
 import { hasOwnSandboxProperty } from "./globals/object.js";
 import { isSandboxMapConstructor, isSandboxSetConstructor } from "./globals/collections.js";
+import { collectionIteratorState, isSandboxCollectionIterator } from "./collection-iterator.js";
+import { getCollectionIteratorMember } from "./methods/collection-iterator.js";
 import { getFloat32Member, isFloat32ArrayConstructor, setFloat32Member } from "./globals/float32array.js";
 import { isFloat32Array } from "./float32.js";
 import { dateString, dateTime, isSandboxDate } from "./date.js";
@@ -734,6 +736,9 @@ function isRestorableBindingValue(value, seen = new WeakSet()) {
     if (seen.has(value))
         return true;
     seen.add(value);
+    if (isSandboxCollectionIterator(value)) {
+        return isRestorableBindingValue(collectionIteratorState(value).collection, seen);
+    }
     if (isSandboxMap(value)) {
         for (const [key, entry] of value.entries) {
             if (!isRestorableBindingValue(key, seen) || !isRestorableBindingValue(entry, seen)) {
@@ -977,7 +982,7 @@ async function evaluateForOfStatement(node, context) {
         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])) {
+            if (isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0]) || isSandboxCollectionIterator(restored.value[0])) {
                 return evaluateForOfIterator(node, restored.value[0], context, restoredEntry);
             }
         }
@@ -1025,7 +1030,7 @@ async function evaluateForOfStatement(node, context) {
     };
 }
 async function evaluateForOfIterator(node, value, context, restoredEntry) {
-    const iterator = getSandboxIterator(value);
+    const iterator = getSandboxIterator(value, context.budget);
     if (iterator === undefined) {
         throw new TypeError(`${String(value)} is not a supported iterable`);
     }
@@ -1341,7 +1346,7 @@ function createLoopIterationContext(context, scope) {
             snapshot.loopIterations = {};
             for (const [nodeId, iteration] of context.activeLoopIterations) {
                 if (typeof iteration !== "number" &&
-                    (isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]))) {
+                    (isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]) || isSandboxCollectionIterator(iteration.values[0]))) {
                     const bindingName = `#for-of:${nodeId}`;
                     snapshot.bindings[bindingName] = iteration.values;
                     snapshot.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
@@ -1469,7 +1474,7 @@ async function evaluateYieldDelegate(node, context) {
     if (argument.kind !== "normal") {
         return argument;
     }
-    const iterator = getSandboxIterator(argument.value);
+    const iterator = getSandboxIterator(argument.value, context.budget);
     if (iterator === undefined) {
         throw new TypeError(`${String(argument.value)} is not a supported iterable`);
     }
@@ -1679,6 +1684,8 @@ function getPropertyValue(target, property, context) {
         return getMapMember(target, property, createMapMethodOptions(context));
     if (isSandboxSet(target))
         return getSetMember(target, property, createSetMethodOptions(context));
+    if (isSandboxCollectionIterator(target))
+        return getCollectionIteratorMember(target, property, context.budget);
     if (isSandboxGenerator(target))
         return getGeneratorMember(target, property, context.budget);
     if (isSandboxClosure(target))
@@ -1695,6 +1702,7 @@ function getPropertyValue(target, property, context) {
 export function createPatternContext(context, scope = context.scope, evaluate = evaluateNode) {
     const evaluationContext = { ...context, scope };
     return {
+        budget: context.budget,
         evaluate: node => evaluate(node, evaluationContext),
         toPropertyKey: value => toPropertyKey(value, context.budget, createCoercionContext(evaluationContext)),
         getProperty: (value, key) => getPropertyValue(value, key, evaluationContext),
@@ -2141,7 +2149,7 @@ function hasSandboxProperty(value, key, context) {
         if (hasOwnSandboxProperty(current, key, false))
             return true;
         if (Array.isArray(current) || !isPlainSandboxObject(current) ||
-            isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current)) {
+            isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current)) {
             return getPropertyValue(current, key, context) !== undefined;
         }
         current = getSandboxPrototype(current, context.budget);
@@ -2359,7 +2367,7 @@ function getMemberValue(target, property, context) {
             return getClosureMemberValue(current, property, context);
         if (Array.isArray(current))
             return getArrayMemberValue(current, property, context);
-        if (!isPlainSandboxObject(current) || isSandboxGenerator(current) || isFloat32Array(current)) {
+        if (!isPlainSandboxObject(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isFloat32Array(current)) {
             return getPropertyValue(current, property, context);
         }
         if (Object.hasOwn(current, String(property)))
@@ -2578,7 +2586,7 @@ async function evaluateSpreadElement(node, context) {
             result: value
         };
     }
-    const iterator = getSpreadIterator(value.value);
+    const iterator = getSandboxIterator(value.value, context.budget);
     if (iterator === undefined) {
         throw new TypeError("Spread arguments must evaluate to an iterable.");
     }
@@ -2647,9 +2655,6 @@ function describeObjectSpreadValue(value) {
     }
     return typeof value;
 }
-function getSpreadIterator(value) {
-    return getSandboxIterator(value);
-}
 async function closeIterator(iterator) {
     if (iterator.generator && iterator.return !== undefined) {
         await iterator.return();

package/packages/safe-js/dist/interp/iteration.d.ts

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

package/packages/safe-js/dist/interp/iteration.js

@@ -2,7 +2,10 @@ import { isSandboxGenerator, isSandboxMap, isSandboxSet } from "./values.js";
 import { enterRunningState } from "./running-state.js";
 import { isFloat32Array } from "./float32.js";
 import { getHostObjectIterator, isGuestHostObject } from "./host-capabilities.js";
-export function getSandboxIterator(value) {
+import { isSandboxCollectionIterator, nextCollectionIterator } from "./collection-iterator.js";
+export function getSandboxIterator(value, budget) {
+    if (isSandboxCollectionIterator(value))
+        return { next: () => nextCollectionIterator(value, budget), snapshotIndex: () => 0 };
     if (isGuestHostObject(value))
         return getHostObjectIterator(value);
     if (isFloat32Array(value)) {

package/packages/safe-js/dist/interp/methods/collection-iterator.d.ts

@@ -0,0 +1,4 @@
+import type { Budget } from "../budget.js";
+import { type SandboxCollectionIterator } from "../collection-iterator.js";
+import { type SandboxValue } from "../values.js";
+export declare function getCollectionIteratorMember(target: SandboxCollectionIterator, property: string | number, budget: Budget): SandboxValue;

package/packages/safe-js/dist/interp/methods/collection-iterator.js

@@ -0,0 +1,19 @@
+import { collectionIteratorState, isSandboxCollectionIterator, nextCollectionIterator } from "../collection-iterator.js";
+import { createSandboxClosure } from "../values.js";
+export function getCollectionIteratorMember(target, property, budget) {
+    if (Object.hasOwn(target, property))
+        return target[property];
+    if (property !== "next")
+        return undefined;
+    const { collectionKind } = collectionIteratorState(target);
+    return createSandboxClosure({
+        sandbox: true,
+        name: "next",
+        call: (_args, context) => {
+            const receiver = context?.thisValue;
+            if (!isSandboxCollectionIterator(receiver) || collectionIteratorState(receiver).collectionKind !== collectionKind)
+                throw new TypeError("Iterator next requires a matching collection iterator receiver.");
+            return nextCollectionIterator(receiver, budget);
+        }
+    });
+}

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

@@ -1,6 +1,7 @@
-import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxMap } from "../values.js";
+import { createSandboxClosure, isSandboxClosure, isSandboxMap } from "../values.js";
 import { assertCollectionMutable } from "../running-state.js";
 import { enterKeyedCollectionCallback, updateKeyedCollectionCallbacks } from "./collection-callback.js";
+import { createSandboxCollectionIterator } from "../collection-iterator.js";
 const mapMethodNames = new Set([
     "get",
     "set",
@@ -80,10 +81,8 @@ export async function callMapMethod(target, methodName, args, options, stack = [
             return undefined;
         }
         case "keys":
-            return allocateProducedSandboxValue([...target.entries.keys()], options.budget);
         case "values":
-            return allocateProducedSandboxValue([...target.entries.values()], options.budget);
         case "entries":
-            return allocateProducedSandboxValue([...target.entries].map(([key, value]) => [key, value]), options.budget);
+            return createSandboxCollectionIterator(target, methodName);
     }
 }

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

@@ -1,6 +1,7 @@
-import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxSet } from "../values.js";
+import { createSandboxClosure, isSandboxClosure, isSandboxSet } from "../values.js";
 import { assertCollectionMutable } from "../running-state.js";
 import { enterKeyedCollectionCallback, updateKeyedCollectionCallbacks } from "./collection-callback.js";
+import { createSandboxCollectionIterator } from "../collection-iterator.js";
 const setMethodNames = new Set([
     "add",
     "has",
@@ -77,8 +78,7 @@ export async function callSetMethod(target, methodName, args, options, stack = [
         }
         case "keys":
         case "values":
-            return allocateProducedSandboxValue([...target.values], options.budget);
         case "entries":
-            return allocateProducedSandboxValue([...target.values].map((value) => [value, value]), options.budget);
+            return createSandboxCollectionIterator(target, methodName);
     }
 }

package/packages/safe-js/dist/interp/patterns.d.ts

@@ -1,6 +1,7 @@
 import type { AssignmentPattern, MemberExpression, ParseResult, RestElement, VariableDeclarationKind, VariableDeclarator } from "../parse.js";
 import type { AsyncEvaluationResult } from "./async.js";
 import type { Scope } from "./scope.js";
+import type { Budget } from "./budget.js";
 import { type SandboxValue } from "./values.js";
 type Pattern = VariableDeclarator["id"] | AssignmentPattern | MemberExpression | RestElement;
 export type PatternTarget = {
@@ -10,6 +11,7 @@ export type PatternTarget = {
     assign: true;
 };
 export type PatternContext = {
+    budget?: Budget;
     evaluate(node: ParseResult): Promise<AsyncEvaluationResult>;
     toPropertyKey(value: SandboxValue): Promise<string>;
     getProperty(value: SandboxValue, key: string | number): SandboxValue;

package/packages/safe-js/dist/interp/patterns.js

@@ -1,3 +1,4 @@
+import { isSandboxCollectionIterator, nextCollectionIterator } from "./collection-iterator.js";
 import { isSandboxMap, isSandboxSet, ownEnumerableSandboxEntries } from "./values.js";
 export async function bindPattern(pattern, value, target, scope, context) {
     switch (pattern.type) {
@@ -46,13 +47,30 @@ async function bindAssignmentPattern(pattern, value, target, scope, context) {
     return bindPattern(pattern.left, defaultValue.value, target, scope, context);
 }
 async function bindArrayPattern(pattern, value, target, scope, context) {
-    const values = getArrayPatternValues(value);
+    const iterator = isSandboxCollectionIterator(value) ? value : undefined;
+    const values = iterator === undefined ? getArrayPatternValues(value) : undefined;
     for (let index = 0; index < pattern.elements.length; index += 1) {
         const element = pattern.elements[index];
         if (element === null) {
+            if (iterator !== undefined)
+                nextCollectionIterator(iterator, context.budget);
             continue;
         }
-        const elementValue = element.type === "RestElement" ? values.slice(index) : values[index];
+        let elementValue;
+        if (iterator === undefined) {
+            elementValue = element.type === "RestElement" ? values.slice(index) : values[index];
+        }
+        else if (element.type === "RestElement") {
+            const rest = [];
+            for (let entry = nextCollectionIterator(iterator, context.budget); !entry.done; entry = nextCollectionIterator(iterator, context.budget)) {
+                context.budget?.allocateArrayLength(rest.length + 1);
+                rest.push(entry.value);
+            }
+            elementValue = rest;
+        }
+        else {
+            elementValue = nextCollectionIterator(iterator, context.budget).value;
+        }
         const binding = await bindPattern(element, elementValue, target, scope, context);
         if (!binding.ok) {
             return binding;

package/packages/safe-js/dist/interp/promise.js

@@ -337,7 +337,7 @@ async function settleIterable(iterable, method, budget, constructor, context) {
         const promiseResolve = readPromiseReceiverProperty(constructor, "resolve", prototype);
         if (!isSandboxClosure(promiseResolve))
             throw new TypeError("Promise constructor requires a callable resolve.");
-        const iterator = getSandboxIterator(iterable);
+        const iterator = getSandboxIterator(iterable, budget);
         if (iterator === undefined)
             throw new TypeError("Promise helpers require an iterable.");
         let index = 0;

package/packages/safe-js/dist/interp/string-coercion.js

@@ -4,6 +4,7 @@ import { invokeBuiltinClosure } from "./builtin-call.js";
 import { float32Storage, isFloat32Array } from "./float32.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { isGuestHostObject } from "./host-capabilities.js";
+import { collectionIteratorState, isSandboxCollectionIterator } from "./collection-iterator.js";
 import { getGuestFunctionProperties, getSandboxPrototype, hasExplicitSandboxPrototype, isGuestClosure } from "./object-model.js";
 import { getRegexMember } from "./methods/regex.js";
 import { isSandboxClosure, isSandboxPromise, isSandboxMap, isSandboxSet, isSandboxRegex, isSandboxGenerator } from "./values.js";
@@ -65,6 +66,7 @@ function conversionHook(value, name, budget) {
             isSandboxClosure(value) ||
             isSandboxMap(value) ||
             isSandboxSet(value) ||
+            isSandboxCollectionIterator(value) ||
             isSandboxPromise(value) ||
             isSandboxRegex(value) ||
             isSandboxGenerator(value) ||
@@ -97,6 +99,8 @@ async function defaultToString(value, budget, context, joining) {
         return "[object Map]";
     if (isSandboxSet(value))
         return "[object Set]";
+    if (isSandboxCollectionIterator(value))
+        return collectionIteratorState(value).collectionKind === "map" ? "[object Map Iterator]" : "[object Set Iterator]";
     if (isSandboxGenerator(value))
         return "[object Generator]";
     if (isSandboxRegex(value)) {

package/packages/safe-js/dist/interp/values.d.ts

@@ -1,18 +1,19 @@
+import { sandboxMapBrand, sandboxSetBrand } from "./collection-brands.js";
+import { type SandboxCollectionIterator } from "./collection-iterator.js";
 import type { Budget, CompileTicket } from "./budget.js";
 import { CompileScope } from "./regex/compile-guard.js";
 import type { GeneratorChannel } from "./generator.js";
 import { type RegexPattern } from "./regex/parse.js";
 export { createSandboxArguments, isSandboxArguments } from "./arguments.js";
+export { isSandboxMap, isSandboxSet } from "./collection-brands.js";
 declare const sandboxClosureBrand: unique symbol;
 declare const sandboxGeneratorBrand: unique symbol;
-declare const sandboxMapBrand: unique symbol;
 declare const sandboxPromiseBrand: unique symbol;
 declare const sandboxRegexBrand: unique symbol;
 declare const sandboxRegexPattern: unique symbol;
-declare const sandboxSetBrand: unique symbol;
 declare const sandboxRetainedValues: unique symbol;
 export type SandboxPrimitive = string | number | boolean | null | undefined;
-export type SandboxValue = SandboxPrimitive | Date | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
+export type SandboxValue = SandboxPrimitive | Date | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxCollectionIterator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
 export type SandboxObject = {
     [key: string]: SandboxValue;
 };
@@ -123,9 +124,7 @@ export declare function createSandboxSet(values?: Iterable<SandboxValue>): Sandb
 export declare function createSandboxRegex(source: string, flags?: string, lastIndex?: number, compilation?: CompileScope): SandboxRegex;
 export declare function getSandboxRegexPattern(regex: SandboxRegex): RegexPattern;
 export declare function isSandboxClosure(value: unknown): value is SandboxClosure;
-export declare function isSandboxMap(value: unknown): value is SandboxMap;
 export declare function isSandboxPromise(value: unknown): value is SandboxPromise;
-export declare function isSandboxSet(value: unknown): value is SandboxSet;
 export declare function isSandboxGenerator(value: unknown): value is SandboxGenerator;
 export declare function isSandboxRegex(value: unknown): value is SandboxRegex;
 export declare function deepCopyToSandbox(value: unknown): SandboxValue;