@poe-platform/safe-js 0.1.110 → 0.1.112

package/dist/safe-js/chunks/{chunk-FPFTLLMZ.js → chunk-7Z6HCXET.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-OCJ6MUNL.js";
+} from "./chunk-DVWTNFTV.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-FPFTLLMZ.js.map
+//# sourceMappingURL=chunk-7Z6HCXET.js.map

package/dist/safe-js/chunks/{chunk-OCJ6MUNL.js → chunk-DVWTNFTV.js}

@@ -6337,6 +6337,72 @@ function serializedDateTime(value) {
   return Number.isNaN(time) ? null : time;
 }
 
+// packages/safe-js/src/interp/collection-brands.ts
+var sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
+var sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
+function isSandboxMap(value) {
+  return typeof value === "object" && value !== null && sandboxMapBrand in value;
+}
+function isSandboxSet(value) {
+  return typeof value === "object" && value !== null && sandboxSetBrand in value;
+}
+
+// packages/safe-js/src/interp/collection-iterator.ts
+var states = /* @__PURE__ */ new WeakMap();
+function isSandboxCollectionIterator(value) {
+  return typeof value === "object" && value !== null && states.has(value);
+}
+function createSandboxCollectionIterator(collection, method) {
+  return restoreSandboxCollectionIterator({ collection, collectionKind: collection.kind, method, index: 0, exhausted: false });
+}
+function restoreSandboxCollectionIterator(snapshot, target = /* @__PURE__ */ Object.create(null)) {
+  const { collection, collectionKind, method, index, exhausted } = snapshot;
+  if (collection !== void 0 && collection.kind !== collectionKind)
+    throw new TypeError("Collection iterator source has the wrong brand.");
+  if (!exhausted && collection === void 0)
+    throw new TypeError("Live collection iterator requires its source collection.");
+  const iterator = exhausted ? void 0 : nativeIterator(collection, method);
+  for (let skipped = 0; skipped < index; skipped += 1) {
+    if (iterator === void 0 || iterator.next().done)
+      throw new TypeError("Collection iterator cursor exceeds its source.");
+  }
+  states.set(target, { collection: exhausted ? void 0 : collection, collectionKind, method, exhausted, iterator });
+  return target;
+}
+function collectionIteratorState(value) {
+  const state = states.get(value);
+  if (state === void 0) throw new TypeError("Expected a collection iterator.");
+  return state;
+}
+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;
+}
+function nextCollectionIterator(value, budget) {
+  const state = states.get(value);
+  budget?.visitNode();
+  if (state.exhausted) return { value: void 0, done: true };
+  const result = state.iterator.next();
+  if (result.done) {
+    state.exhausted = true;
+    state.collection = void 0;
+    state.iterator = void 0;
+    return { value: void 0, 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]();
+}
+
 // packages/safe-js/src/interp/host-capabilities.ts
 import { types as types3 } from "node:util";
 var MAX_INDEXED_LENGTH = 65536;
@@ -6909,16 +6975,19 @@ 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 : void 0;
+  if (map !== void 0) {
+    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 : void 0;
+  if (set !== void 0) {
+    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 !== void 0 && "value" in descriptor)
@@ -7581,6 +7650,7 @@ function validateTaggedValue(record2, path, state) {
     case "object":
     case "map":
     case "set":
+    case "collection-iterator":
       return;
   }
 }
@@ -8548,7 +8618,7 @@ async function objectToPrimitive(value, budget, context, joining, hint) {
   }
 }
 function conversionHook(value, name, budget) {
-  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) || isSandboxDate(value) || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value) || isSandboxGenerator(value) || isGuestHostObject(value));
+  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) || isSandboxDate(value) || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) || isSandboxGenerator(value) || isGuestHostObject(value));
   let current = value;
   let depth = 0;
   while (current !== null) {
@@ -8574,6 +8644,7 @@ function conversionHook(value, name, budget) {
 async function defaultToString(value, budget, context, joining) {
   if (isSandboxMap(value)) 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)) {
     return budget.allocateString(
@@ -9119,7 +9190,8 @@ function assertSnapshotInactive(snapshot) {
 }
 
 // packages/safe-js/src/interp/iteration.ts
-function getSandboxIterator(value) {
+function getSandboxIterator(value, budget) {
+  if (isSandboxCollectionIterator(value)) return { next: () => nextCollectionIterator(value, budget), snapshotIndex: () => 0 };
   if (isGuestHostObject(value)) return getHostObjectIterator(value);
   if (isFloat32Array(value)) {
     return syncIterator(Float32Array.prototype.values.call(value));
@@ -9685,7 +9757,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 === void 0) throw new TypeError("Promise helpers require an iterable.");
     let index = 0;
     while (true) {
@@ -10127,6 +10199,7 @@ function registerCancelablePromises(value, signal) {
     } else if (isSandboxSet(current)) {
       for (const entry of current.values) 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);
       }
@@ -10228,11 +10301,9 @@ function isPromiseLike2(value) {
 // packages/safe-js/src/interp/values.ts
 var sandboxClosureBrand = /* @__PURE__ */ Symbol("SandboxClosure");
 var sandboxGeneratorBrand = /* @__PURE__ */ Symbol("SandboxGenerator");
-var sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
 var sandboxPromiseBrand = /* @__PURE__ */ Symbol("SandboxPromise");
 var sandboxRegexBrand = /* @__PURE__ */ Symbol("SandboxRegex");
 var sandboxRegexPattern = /* @__PURE__ */ Symbol("SandboxRegexPattern");
-var sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
 var sandboxRetainedValues = /* @__PURE__ */ Symbol("SandboxRetainedValues");
 function createSandboxClosure(input) {
   const closure = {
@@ -10399,15 +10470,9 @@ function getSandboxRegexPattern(regex) {
 function isSandboxClosure(value) {
   return typeof value === "object" && value !== null && sandboxClosureBrand in value;
 }
-function isSandboxMap(value) {
-  return typeof value === "object" && value !== null && sandboxMapBrand in value;
-}
 function isSandboxPromise(value) {
   return typeof value === "object" && value !== null && sandboxPromiseBrand in value;
 }
-function isSandboxSet(value) {
-  return typeof value === "object" && value !== null && sandboxSetBrand in value;
-}
 function isSandboxGenerator(value) {
   return typeof value === "object" && value !== null && sandboxGeneratorBrand in value;
 }
@@ -10420,14 +10485,18 @@ function deepCopyToSandbox(value) {
   });
 }
 function cloneSandboxValue(value) {
-  return copyToSandbox(
+  const initializeIterators = [];
+  const copy = copyToSandbox(
     value,
     {
-      seen: /* @__PURE__ */ new WeakMap()
+      seen: /* @__PURE__ */ new WeakMap(),
+      initializeIterators
     },
     "<root>",
     true
   );
+  for (const initialize of initializeIterators) initialize();
+  return copy;
 }
 function allocateProducedSandboxValue(value, budget) {
   allocateSandboxValue2(value, budget, /* @__PURE__ */ new WeakSet());
@@ -10492,6 +10561,14 @@ function measureSandboxData(values, options = {}) {
       }
       return;
     }
+    if (isSandboxCollectionIterator(value)) {
+      visit(collectionIteratorState(value).collection, depth + 1);
+      for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        usage += key.length + 1;
+        if ("value" in descriptor) visit(descriptor.value, depth + 1);
+      }
+      return;
+    }
     if (isSandboxSet(value)) {
       usage += value.values.size;
       for (const entry of value.values) visit(entry, depth + 1);
@@ -10600,6 +10677,24 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxRegex(value) || isSandboxPromise(value)) {
     return value;
   }
+  if (isSandboxCollectionIterator(value)) {
+    if (hasGuestObjectState(value)) throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
+    if (!cloneSandboxCollections) return value;
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const snapshot = snapshotCollectionIterator(value);
+    const copy = restoreSandboxCollectionIterator({ ...snapshot, collection: void 0, index: 0, exhausted: true });
+    state.seen.set(value, copy);
+    const collection = copyToSandbox(snapshot.collection, state, `${path}.<collection>`, true, depth + 1);
+    if (collection !== void 0 && !isSandboxMap(collection) && !isSandboxSet(collection)) throw new TypeError("Invalid cloned collection iterator source.");
+    state.initializeIterators.push(() => {
+      restoreSandboxCollectionIterator({ ...snapshot, collection }, copy);
+    });
+    for (const entry of getEnumerableObjectEntries(value, path)) {
+      defineOwnDataProperty(copy, entry.key, copyToSandbox(entry.value, state, joinPath(path, entry.key), true, depth + 1));
+    }
+    return copy;
+  }
   if (typeof value === "object" && value !== null && hasGuestObjectState(value)) {
     throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
   }
@@ -10855,6 +10950,9 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
   if (isSandboxGenerator(value)) {
     throw new TypeError("Sandbox generators cannot cross into host values.");
   }
+  if (isSandboxCollectionIterator(value)) {
+    throw new TypeError("Sandbox collection iterators cannot cross into host values.");
+  }
   if (isSandboxRegex(value)) {
     throw new TypeError("Invalid sandbox RegExp brand.");
   }
@@ -11148,6 +11246,14 @@ function encodeReplayData(value, options = {}) {
         };
       }
       nodes[id] = { ...storage, properties, extensible: Object.isExtensible(entry) };
+    } else if (isSandboxCollectionIterator(entry)) {
+      const snapshot = snapshotCollectionIterator(entry);
+      const properties = /* @__PURE__ */ Object.create(null);
+      for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(entry))) {
+        if (!("value" in descriptor)) throw new TypeError(`Cannot record replay data accessor '${key}'.`);
+        properties[key] = { value: child(descriptor.value, JSON.stringify(["property", key])), configurable: descriptor.configurable === true, enumerable: descriptor.enumerable === true, writable: descriptor.writable === true };
+      }
+      nodes[id] = { kind: "collection-iterator", collectionKind: snapshot.collectionKind, method: snapshot.method, collection: child(snapshot.collection, "<collection>"), index: snapshot.index, exhausted: snapshot.exhausted, properties, extensible: Object.isExtensible(entry) };
     } else if (isSandboxMap(entry)) {
       nodes[id] = {
         kind: "map",
@@ -11206,6 +11312,7 @@ function decodeReplayData(input, options = {}, parent) {
     const graph = record(input);
     const nodes = list(own(graph, "nodes"));
     const restored = /* @__PURE__ */ new Map();
+    const initializeIterators = [];
     const decode = (entry, depth = 0) => {
       if (depth > MAX_DATA_DEPTH) throw new TypeError("Replay data exceeds the nesting limit.");
       if (entry === null || typeof entry === "boolean" || typeof entry === "string") return entry;
@@ -11298,6 +11405,23 @@ function decodeReplayData(input, options = {}, parent) {
         if (!node.extensible) Object.preventExtensions(result3);
         return result3;
       }
+      if (kind === "collection-iterator") {
+        const collectionKind = own(node, "collectionKind");
+        const method = own(node, "method");
+        const index = own(node, "index");
+        const exhausted = own(node, "exhausted");
+        if (collectionKind !== "map" && collectionKind !== "set" || method !== "keys" && method !== "values" && method !== "entries" || typeof index !== "number" || !Number.isSafeInteger(index) || index < 0 || typeof exhausted !== "boolean" || typeof node.extensible !== "boolean") throw new TypeError("Invalid replay collection iterator.");
+        const result3 = restoreSandboxCollectionIterator({ collection: void 0, collectionKind, method, index: 0, exhausted: true });
+        restored.set(id, result3);
+        const collection = child(own(node, "collection"));
+        if (collection !== void 0 && !isSandboxMap(collection) && !isSandboxSet(collection)) throw new TypeError("Invalid replay collection iterator source.");
+        initializeIterators.push(() => {
+          restoreSandboxCollectionIterator({ collection, collectionKind, method, index, exhausted }, result3);
+        });
+        defineProperties(result3, record(own(node, "properties")), child);
+        if (!node.extensible) Object.preventExtensions(result3);
+        return result3;
+      }
       if (kind === "map") {
         const result3 = createSandboxMap();
         restored.set(id, result3);
@@ -11354,6 +11478,7 @@ function decodeReplayData(input, options = {}, parent) {
       return result2;
     };
     const result = decode(own(graph, "root"));
+    for (const initialize of initializeIterators) initialize();
     if (parent !== void 0) compilation.forward(compilation.tickets, parent);
     return result;
   } finally {
@@ -23540,13 +23665,27 @@ async function bindAssignmentPattern2(pattern, value, target, scope, context) {
   return bindPattern2(pattern.left, defaultValue.value, target, scope, context);
 }
 async function bindArrayPattern2(pattern, value, target, scope, context) {
-  const values = getArrayPatternValues(value);
+  const iterator = isSandboxCollectionIterator(value) ? value : void 0;
+  const values = iterator === void 0 ? getArrayPatternValues(value) : void 0;
   for (let index = 0; index < pattern.elements.length; index += 1) {
     const element = pattern.elements[index];
     if (element === null) {
+      if (iterator !== void 0) nextCollectionIterator(iterator, context.budget);
       continue;
     }
-    const elementValue = element.type === "RestElement" ? values.slice(index) : values[index];
+    let elementValue;
+    if (iterator === void 0) {
+      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 bindPattern2(element, elementValue, target, scope, context);
     if (!binding.ok) {
       return binding;
@@ -24528,7 +24667,11 @@ function getMapMember(target, property, options) {
   }
   return createSandboxClosure({
     sandbox: true,
-    call: (args, context) => callMapMethod(target, property, args, options, context?.stack ?? []),
+    call: (args, context) => {
+      const receiver = context?.thisValue;
+      if (!isSandboxMap(receiver)) throw new TypeError(`Map#${property} requires a Map receiver.`);
+      return callMapMethod(receiver, property, args, options, context?.stack ?? []);
+    },
     name: property
   });
 }
@@ -24576,14 +24719,9 @@ async function callMapMethod(target, methodName, args, options, stack = []) {
       return void 0;
     }
     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);
   }
 }
 
@@ -25130,7 +25268,11 @@ function getSetMember(target, property, options) {
   }
   return createSandboxClosure({
     sandbox: true,
-    call: (args, context) => callSetMethod(target, property, args, options, context?.stack ?? []),
+    call: (args, context) => {
+      const receiver = context?.thisValue;
+      if (!isSandboxSet(receiver)) throw new TypeError(`Set#${property} requires a Set receiver.`);
+      return callSetMethod(receiver, property, args, options, context?.stack ?? []);
+    },
     name: property
   });
 }
@@ -25176,12 +25318,8 @@ 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);
   }
 }
 
@@ -25356,6 +25494,7 @@ function typeTag(value) {
   if (isSandboxRegex(value)) return "RegExp";
   if (isSandboxMap(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)) return "Generator";
   if (isFloat32Array(value)) return "Float32Array";
@@ -25444,7 +25583,7 @@ function isSandboxSetConstructor(value) {
 function populateCollection(source, collection, { name, budget, context, append, retainedValues }) {
   budget.allocateCollectionEntries(0);
   if (source === void 0 || source === null) return collection;
-  const iterator = getSandboxIterator(source);
+  const iterator = getSandboxIterator(source, budget);
   if (iterator === void 0) throw new TypeError(`${name} constructor requires an iterable.`);
   let entry;
   let failure;
@@ -25505,6 +25644,23 @@ function populateCollection(source, collection, { name, budget, context, append,
   }
 }
 
+// packages/safe-js/src/interp/methods/collection-iterator.ts
+function getCollectionIteratorMember(target, property, budget) {
+  if (Object.hasOwn(target, property)) return target[property];
+  if (property !== "next") return void 0;
+  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);
+    }
+  });
+}
+
 // packages/safe-js/src/interp/globals/float32array.ts
 var constructors = /* @__PURE__ */ new WeakSet();
 function createFloat32ArrayGlobal(budget) {
@@ -26689,6 +26845,9 @@ function isRestorableBindingValue(value, seen = /* @__PURE__ */ 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)) {
@@ -26931,7 +27090,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);
       }
     }
@@ -26979,7 +27138,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 === void 0) {
     throw new TypeError(`${String(value)} is not a supported iterable`);
   }
@@ -27278,7 +27437,7 @@ function createLoopIterationContext(context, scope) {
       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]))) {
+        if (typeof iteration !== "number" && (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] };
@@ -27405,7 +27564,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 === void 0) {
     throw new TypeError(`${String(argument.value)} is not a supported iterable`);
   }
@@ -27615,6 +27774,7 @@ function getPropertyValue(target, property, context) {
   if (isSandboxDate(target)) return getDateMember(property, context.budget, context.compilation?.owner);
   if (isSandboxMap(target)) 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)) return getClosureMemberValue(target, property, context);
   if (isSandboxPromise(target)) return getPromiseMember(property, context.budget);
@@ -27627,6 +27787,7 @@ function getPropertyValue(target, property, context) {
 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),
@@ -28134,7 +28295,7 @@ function hasSandboxProperty(value, key, context) {
   while (typeof current === "object" && current !== null) {
     if (isGuestHostObject(current)) return hasHostObjectMember(current, key);
     if (hasOwnSandboxProperty(current, key, false)) return true;
-    if (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current)) {
+    if (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current)) {
       return getPropertyValue(current, key, context) !== void 0;
     }
     current = getSandboxPrototype(current, context.budget);
@@ -28344,7 +28505,7 @@ function getMemberValue(target, property, context) {
   while (typeof current === "object" && current !== null) {
     if (isSandboxClosure(current)) 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))) return current[String(property)];
@@ -28559,7 +28720,7 @@ async function evaluateSpreadElement(node, context) {
       result: value
     };
   }
-  const iterator = getSpreadIterator(value.value);
+  const iterator = getSandboxIterator(value.value, context.budget);
   if (iterator === void 0) {
     throw new TypeError("Spread arguments must evaluate to an iterable.");
   }
@@ -28629,9 +28790,6 @@ function describeObjectSpreadValue(value) {
   }
   return typeof value;
 }
-function getSpreadIterator(value) {
-  return getSandboxIterator(value);
-}
 async function closeIterator(iterator) {
   if (iterator.generator && iterator.return !== void 0) {
     await iterator.return();
@@ -30416,8 +30574,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;
@@ -30545,7 +30703,7 @@ function createObjectArrayGlobals(options) {
       fromEntries: createSandboxClosure({
         sandbox: true,
         call: ([value], context) => {
-          const iterator = getSandboxIterator(value);
+          const iterator = getSandboxIterator(value, options.budget);
           if (iterator === void 0) {
             throw new TypeError("Object.fromEntries requires an iterable.");
           }
@@ -30808,7 +30966,7 @@ async function arrayFromSandboxValues(args, budget, context) {
     throw new TypeError("Array.from requires a non-null input.");
   }
   const read = (property) => context?.getProperty !== void 0 ? 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;
@@ -32388,6 +32546,16 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
       throw new TypeError("Invalid replay input capability path.");
     let value = current;
     for (const key of path) {
+      if (isSandboxCollectionIterator(value)) {
+        if (key === "<collection>") value = collectionIteratorState(value).collection;
+        else {
+          const property = JSON.parse(key);
+          if (!Array.isArray(property) || property.length !== 2 || property[0] !== "property" || typeof property[1] !== "string") throw new TypeError("Invalid replay input iterator capability path.");
+          const descriptor2 = Object.getOwnPropertyDescriptor(value, property[1]);
+          value = descriptor2 !== void 0 && "value" in descriptor2 ? descriptor2.value : void 0;
+        }
+        continue;
+      }
       if (isSandboxMap(value)) {
         const [kind, ordinal] = key.split(":");
         const index = Number(ordinal);
@@ -32448,11 +32616,11 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
   return { values: restored, snapshot: structuredClone(saved) };
 }
 function assertReplayInputShape(restored) {
-  if (restored === null || typeof restored !== "object" || Array.isArray(restored) || isSandboxClosure(restored) || isSandboxPromise(restored) || isSandboxMap(restored) || isSandboxSet(restored))
+  if (restored === null || typeof restored !== "object" || Array.isArray(restored) || isSandboxClosure(restored) || isSandboxPromise(restored) || isSandboxCollectionIterator(restored) || isSandboxMap(restored) || isSandboxSet(restored))
     throw new TypeError("Invalid replay inputs.");
   const values = restored;
   for (const key of ["bindings", "imports"]) {
-    if (values[key] === null || typeof values[key] !== "object" || Array.isArray(values[key]) || isSandboxClosure(values[key]) || isSandboxPromise(values[key]) || isSandboxMap(values[key]) || isSandboxSet(values[key]))
+    if (values[key] === null || typeof values[key] !== "object" || Array.isArray(values[key]) || isSandboxClosure(values[key]) || isSandboxPromise(values[key]) || isSandboxCollectionIterator(values[key]) || isSandboxMap(values[key]) || isSandboxSet(values[key]))
       throw new TypeError(`Invalid replay input ${key}.`);
   }
   if (values.entryPointArgs !== void 0 && !Array.isArray(values.entryPointArgs))
@@ -33045,4 +33213,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-OCJ6MUNL.js.map
+//# sourceMappingURL=chunk-DVWTNFTV.js.map