poe-code 14.0.51 → 14.0.53

package/dist/index.js

@@ -12249,7 +12249,7 @@ function matchSubsequence(query, text5) {
   const textCharacters = Array.from(text5);
   let previousStates = [];
   for (let queryIndex = 0; queryIndex < queryCharacters.length; queryIndex += 1) {
-    const states = [];
+    const states2 = [];
     let offset = 0;
     for (let textIndex = 0; textIndex < textCharacters.length; textIndex += 1) {
       const character2 = textCharacters[textIndex];
@@ -12260,7 +12260,7 @@ function matchSubsequence(query, text5) {
       }
       const positions = character2.length === 2 ? [position, position + 1] : [position];
       if (queryIndex === 0) {
-        states[textIndex] = {
+        states2[textIndex] = {
           score: characterScore(textCharacters, textIndex, void 0) + Math.max(0, EARLY_MATCH_BONUS - position),
           positions
         };
@@ -12275,12 +12275,12 @@ function matchSubsequence(query, text5) {
           score: previous.score + characterScore(textCharacters, textIndex, previousIndex),
           positions: [...previous.positions, ...positions]
         };
-        if (isBetterMatch(next, states[textIndex])) {
-          states[textIndex] = next;
+        if (isBetterMatch(next, states2[textIndex])) {
+          states2[textIndex] = next;
         }
       }
     }
-    previousStates = states;
+    previousStates = states2;
     if (!previousStates.some((state) => state !== void 0)) {
       return void 0;
     }
@@ -21524,14 +21524,14 @@ function validateMachine(machine) {
   if (!hasOwnRecordField(machine, "states") || !isStateList(machine.states)) {
     throw new TypeError("State machine states must be a string array.");
   }
-  const states = new Set(machine.states);
+  const states2 = new Set(machine.states);
   if (machine.states.some((state) => !hasVisibleName(state))) {
     throw new Error("State names must not be empty.");
   }
   if (!hasOwnRecordField(machine, "initial") || typeof machine.initial !== "string") {
     throw new TypeError("State machine initial must be a string.");
   }
-  if (!states.has(machine.initial)) {
+  if (!states2.has(machine.initial)) {
     throw new Error(`Initial state "${machine.initial}" is not declared.`);
   }
   if (!hasOwnRecordField(machine, "events") || !isRecord9(machine.events)) {
@@ -21550,12 +21550,12 @@ function validateMachine(machine) {
     if (!hasOwnRecordField(event, "to") || typeof event.to !== "string") {
       throw new TypeError(`Event "${eventName}" target state must be a string.`);
     }
-    if (!states.has(event.to)) {
+    if (!states2.has(event.to)) {
       throw new Error(`Event "${eventName}" references unknown target state "${event.to}".`);
     }
     if (event.from !== "*") {
       for (const fromState of event.from) {
-        if (!states.has(fromState)) {
+        if (!states2.has(fromState)) {
           throw new Error(`Event "${eventName}" references unknown source state "${fromState}".`);
         }
       }
@@ -23953,13 +23953,13 @@ async function ghIssuesBackend(deps) {
 }
 function createProjectSession(project, field, labelPrefix) {
   const statusOptions = new Map(field.options.map((option) => [option.name, option.id]));
-  const states = field.options.map((option) => option.name);
+  const states2 = field.options.map((option) => option.name);
   const events = Object.fromEntries(
-    states.map((state) => [state, Object.freeze({ from: "*", to: state })])
+    states2.map((state) => [state, Object.freeze({ from: "*", to: state })])
   );
   const stateMachine = Object.freeze({
-    states: Object.freeze([...states]),
-    initial: states[0],
+    states: Object.freeze([...states2]),
+    initial: states2[0],
     events: Object.freeze(events)
   });
   return Object.freeze({
@@ -80210,8 +80210,8 @@ function hasEmptyStringValue(value) {
   }
   return Object.values(value).some((entry) => hasEmptyStringValue(entry));
 }
-function hasOwnState(states, state) {
-  return Object.prototype.hasOwnProperty.call(states, state);
+function hasOwnState(states2, state) {
+  return Object.prototype.hasOwnProperty.call(states2, state);
 }
 function getOwnEntry29(record2, key3) {
   return Object.prototype.hasOwnProperty.call(record2, key3) ? record2[key3] : void 0;
@@ -80245,7 +80245,7 @@ import path98 from "node:path";
 function resolveConfig2(raw, cwd) {
   const rawConfig = isRecord31(raw) ? raw : {};
   const scoped = resolveScope(maestroConfigScope, rawConfig, process.env);
-  const { states, stateOrder } = parseStates(getOwnEntry30(rawConfig, "states"));
+  const { states: states2, stateOrder } = parseStates(getOwnEntry30(rawConfig, "states"));
   const polling = scoped.polling;
   const workspace = scoped.workspace;
   const agent3 = scoped.agent;
@@ -80254,9 +80254,9 @@ function resolveConfig2(raw, cwd) {
   }
   return {
     tasks: resolveTasks(getOwnEntry30(rawConfig, "tasks"), cwd),
-    states,
-    activeStateNames: stateOrder.filter((name) => states[name]?.prompt !== void 0),
-    terminalStateNames: stateOrder.filter((name) => states[name]?.terminal === true),
+    states: states2,
+    activeStateNames: stateOrder.filter((name) => states2[name]?.prompt !== void 0),
+    terminalStateNames: stateOrder.filter((name) => states2[name]?.terminal === true),
     stateOrder,
     polling: {
       intervalMs: readPositiveInteger(
@@ -80289,13 +80289,13 @@ function resolveConfig2(raw, cwd) {
 }
 function parseStates(value) {
   validateStateDefinitions(value);
-  const states = /* @__PURE__ */ Object.create(null);
+  const states2 = /* @__PURE__ */ Object.create(null);
   const stateOrder = [];
   const entries = value instanceof Map ? value.entries() : Object.entries(value);
   for (const [name, rawDefinition] of entries) {
     const stateName = String(name);
     const definition = rawDefinition;
-    Object.defineProperty(states, stateName, {
+    Object.defineProperty(states2, stateName, {
       configurable: true,
       enumerable: true,
       value: parseStateDefinition(definition),
@@ -80303,7 +80303,7 @@ function parseStates(value) {
     });
     stateOrder.push(stateName);
   }
-  return { states, stateOrder };
+  return { states: states2, stateOrder };
 }
 function parseStateDefinition(definition) {
   const state = {};
@@ -81573,8 +81573,8 @@ var init_phases = __esm({
 function isRunningPhase(phase) {
   return phase === "running-step";
 }
-function hasOwnState2(states, state) {
-  return Object.prototype.hasOwnProperty.call(states, state);
+function hasOwnState2(states2, state) {
+  return Object.prototype.hasOwnProperty.call(states2, state);
 }
 function isAbortError5(error3) {
   return error3 instanceof Error && error3.name === "AbortError";
@@ -82697,7 +82697,7 @@ function createStateStore(stateDir, fs31 = nodeFs7) {
       }
       throw error3;
     }
-    const states = [];
+    const states2 = [];
     for (const entry of [...entries].sort()) {
       if (entry.startsWith(REMOVED_STATE_PREFIX)) {
         continue;
@@ -82716,10 +82716,10 @@ function createStateStore(stateDir, fs31 = nodeFs7) {
       }
       const state = await read(entry);
       if (state !== null) {
-        states.push(state);
+        states2.push(state);
       }
     }
-    return states;
+    return states2;
   }
   async function remove2(id) {
     const processDir = resolveProcessDir(stateDir, id);
@@ -102105,13 +102105,13 @@ function markApprovalsBuiltIn(group) {
 function isApprovalsBuiltIn(node) {
   return node.kind === "group" && node[approvalsGroupSymbol] === true;
 }
-async function loadApprovals(tasks, states = []) {
-  if (states.length === 0) {
+async function loadApprovals(tasks, states2 = []) {
+  if (states2.length === 0) {
     return tasks.all();
   }
   const seenIds = /* @__PURE__ */ new Set();
   const approvals = [];
-  for (const state of states) {
+  for (const state of states2) {
     const matching = await tasks.all({
       state
     });
@@ -125759,6 +125759,84 @@ var init_arguments = __esm({
   }
 });
 
+// packages/safe-js/src/interp/collection-iterator.ts
+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(snapshot2, target = /* @__PURE__ */ Object.create(null)) {
+  const { collection, collectionKind, method, index, exhausted } = snapshot2;
+  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 snapshot2 = { ...state, index: size - remaining };
+  restoreSandboxCollectionIterator(snapshot2, value);
+  return snapshot2;
+}
+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]();
+}
+var states;
+var init_collection_iterator = __esm({
+  "packages/safe-js/src/interp/collection-iterator.ts"() {
+    "use strict";
+    states = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/collection-brands.ts
+function isSandboxMap(value) {
+  return typeof value === "object" && value !== null && sandboxMapBrand in value;
+}
+function isSandboxSet(value) {
+  return typeof value === "object" && value !== null && sandboxSetBrand in value;
+}
+var sandboxMapBrand, sandboxSetBrand;
+var init_collection_brands = __esm({
+  "packages/safe-js/src/interp/collection-brands.ts"() {
+    "use strict";
+    sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
+    sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
+  }
+});
+
 // packages/safe-js/src/graph-depth.ts
 function assertSandboxDataDepth(depth) {
   if (depth > MAX_DATA_DEPTH) {
@@ -125804,16 +125882,19 @@ function graphEntries(value) {
   if (isSandboxArguments(value)) {
     return getSandboxArgumentEntries(value).map(([key3, entry]) => [`.${key3}`, entry]);
   }
-  if (value instanceof Map) {
-    return [...value.entries()].flatMap(([key3, entry], index) => [
+  const map = isSandboxMap(value) ? value.entries : value instanceof Map ? value : void 0;
+  if (map !== void 0) {
+    return [...map.entries()].flatMap(([key3, entry], index) => [
       [`.<map>[${index}].key`, key3],
       [`.<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 key3 of Object.keys(value)) {
     const descriptor = Object.getOwnPropertyDescriptor(value, key3);
     if (descriptor !== void 0 && "value" in descriptor)
@@ -125828,6 +125909,8 @@ var init_graph_depth = __esm({
     init_shape();
     init_budget2();
     init_arguments();
+    init_collection_iterator();
+    init_collection_brands();
     MAX_DATA_DEPTH = 1024;
     SnapshotBudgetError = class extends Error {
       code = "budgetExceeded";
@@ -127159,6 +127242,14 @@ function encodeReplayData(value, options = {}) {
         };
       }
       nodes[id] = { ...storage2, properties, extensible: Object.isExtensible(entry) };
+    } else if (isSandboxCollectionIterator(entry)) {
+      const snapshot2 = snapshotCollectionIterator(entry);
+      const properties = /* @__PURE__ */ Object.create(null);
+      for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(entry))) {
+        if (!("value" in descriptor)) throw new TypeError(`Cannot record replay data accessor '${key3}'.`);
+        properties[key3] = { value: child(descriptor.value, JSON.stringify(["property", key3])), configurable: descriptor.configurable === true, enumerable: descriptor.enumerable === true, writable: descriptor.writable === true };
+      }
+      nodes[id] = { kind: "collection-iterator", collectionKind: snapshot2.collectionKind, method: snapshot2.method, collection: child(snapshot2.collection, "<collection>"), index: snapshot2.index, exhausted: snapshot2.exhausted, properties, extensible: Object.isExtensible(entry) };
     } else if (isSandboxMap(entry)) {
       nodes[id] = {
         kind: "map",
@@ -127217,6 +127308,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;
@@ -127309,6 +127401,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);
@@ -127365,6 +127474,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 {
@@ -127407,6 +127517,7 @@ var init_replay_data = __esm({
   "packages/safe-js/src/snapshot/replay-data.ts"() {
     "use strict";
     init_graph_depth();
+    init_collection_iterator();
     init_object_model();
     init_compile_guard();
     init_float32();
@@ -128492,7 +128603,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) {
@@ -128518,6 +128629,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(
@@ -128574,6 +128686,7 @@ var init_string_coercion = __esm({
     init_float32();
     init_graph_depth();
     init_host_capabilities();
+    init_collection_iterator();
     init_object_model();
     init_regex();
     init_values();
@@ -129106,7 +129219,8 @@ var init_running_state = __esm({
 });
 
 // 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));
@@ -129210,6 +129324,7 @@ var init_iteration = __esm({
     init_running_state();
     init_float32();
     init_host_capabilities();
+    init_collection_iterator();
   }
 });
 
@@ -129684,7 +129799,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) {
@@ -130139,6 +130254,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);
       }
@@ -130240,6 +130356,7 @@ var activeCancellation, sandboxPromises, cancelableOutcomes;
 var init_cancel2 = __esm({
   "packages/safe-js/src/interp/cancel.ts"() {
     "use strict";
+    init_collection_iterator();
     init_object_model();
     init_values();
     init_promise_tracker();
@@ -130418,15 +130535,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;
 }
@@ -130439,14 +130550,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());
@@ -130511,6 +130626,14 @@ function measureSandboxData(values, options = {}) {
       }
       return;
     }
+    if (isSandboxCollectionIterator(value)) {
+      visit(collectionIteratorState(value).collection, depth + 1);
+      for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        usage += key3.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);
@@ -130619,6 +130742,24 @@ function copyToSandbox(value, state, path193 = "<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 snapshot2 = snapshotCollectionIterator(value);
+    const copy = restoreSandboxCollectionIterator({ ...snapshot2, collection: void 0, index: 0, exhausted: true });
+    state.seen.set(value, copy);
+    const collection = copyToSandbox(snapshot2.collection, state, `${path193}.<collection>`, true, depth + 1);
+    if (collection !== void 0 && !isSandboxMap(collection) && !isSandboxSet(collection)) throw new TypeError("Invalid cloned collection iterator source.");
+    state.initializeIterators.push(() => {
+      restoreSandboxCollectionIterator({ ...snapshot2, collection }, copy);
+    });
+    for (const entry of getEnumerableObjectEntries(value, path193)) {
+      defineOwnDataProperty(copy, entry.key, copyToSandbox(entry.value, state, joinPath(path193, 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.");
   }
@@ -130874,6 +131015,9 @@ function copyFromSandbox(value, state, path193 = "<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.");
   }
@@ -131099,11 +131243,13 @@ function joinPath(path193, key3) {
 function joinArrayPath(path193, key3) {
   return isArrayIndexKey(key3) ? `${path193}[${key3}]` : joinPath(path193, key3);
 }
-var sandboxClosureBrand, sandboxGeneratorBrand, sandboxMapBrand, sandboxPromiseBrand, sandboxRegexBrand, sandboxRegexPattern, sandboxSetBrand, sandboxRetainedValues;
+var sandboxClosureBrand, sandboxGeneratorBrand, sandboxPromiseBrand, sandboxRegexBrand, sandboxRegexPattern, sandboxRetainedValues;
 var init_values = __esm({
   "packages/safe-js/src/interp/values.ts"() {
     "use strict";
     init_otel2();
+    init_collection_brands();
+    init_collection_iterator();
     init_date();
     init_host_capabilities();
     init_compile_guard();
@@ -131118,13 +131264,12 @@ var init_values = __esm({
     init_object_model();
     init_arguments();
     init_arguments();
+    init_collection_brands();
     sandboxClosureBrand = /* @__PURE__ */ Symbol("SandboxClosure");
     sandboxGeneratorBrand = /* @__PURE__ */ Symbol("SandboxGenerator");
-    sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
     sandboxPromiseBrand = /* @__PURE__ */ Symbol("SandboxPromise");
     sandboxRegexBrand = /* @__PURE__ */ Symbol("SandboxRegex");
     sandboxRegexPattern = /* @__PURE__ */ Symbol("SandboxRegexPattern");
-    sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
     sandboxRetainedValues = /* @__PURE__ */ Symbol("SandboxRetainedValues");
   }
 });
@@ -131714,6 +131859,7 @@ function validateTaggedValue(record2, path193, state) {
     case "object":
     case "map":
     case "set":
+    case "collection-iterator":
       return;
   }
 }
@@ -143707,13 +143853,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;
@@ -143845,6 +144005,7 @@ function defineProperty(target, key3, value) {
 var init_patterns = __esm({
   "packages/safe-js/src/interp/patterns.ts"() {
     "use strict";
+    init_collection_iterator();
     init_values();
   }
 });
@@ -143882,7 +144043,7 @@ function getArrayMember(value, property, options) {
     return createSandboxClosure({
       sandbox: true,
       name: `Array#${property}`,
-      call: (args, context) => callArrayMethod(value, property, args, options, context?.stack ?? [])
+      call: (args, context) => callArrayMethod(context?.thisValue, property, args, { ...options, context }, context?.stack ?? [])
     });
   }
   return void 0;
@@ -143897,28 +144058,75 @@ function getArrayIndex(property) {
 function isArrayMethodName(property) {
   return typeof property === "string" && arrayMethodNames.has(property);
 }
-async function callArrayMethod(value, methodName, args, options, stack = []) {
-  if (isMutatingArrayMethod(methodName)) {
-    assertCollectionMutable(value);
-  }
-  if (isCallbackArrayMethod(methodName)) {
-    let callbackState = activeArrayCallbacks.get(value);
-    if (callbackState === void 0) {
-      callbackState = { depth: 0, leave: enterRunningState(value) };
-      activeArrayCallbacks.set(value, callbackState);
+async function callArrayMethod(receiver, methodName, args, options, stack = []) {
+  if (receiver === null || receiver === void 0) throw new TypeError("Array method requires a receiver.");
+  if (typeof receiver !== "object") throw new TypeError("Object primitive boxing is not supported.");
+  const retainedReceiver = {};
+  options.budget.setRetainedValues(retainedReceiver, () => [receiver]);
+  try {
+    const value = Array.isArray(receiver) || methodName === "concat" ? receiver : await arrayLikeView(receiver, options);
+    if (isMutatingArrayMethod(methodName)) {
+      assertCollectionMutable(receiver);
     }
-    callbackState.depth += 1;
-    try {
-      return await callArrayMethodUnlocked(value, methodName, args, options, stack);
-    } finally {
-      callbackState.depth -= 1;
-      if (callbackState.depth === 0) {
-        activeArrayCallbacks.delete(value);
-        callbackState.leave();
+    if (isCallbackArrayMethod(methodName)) {
+      let callbackState = activeArrayCallbacks.get(receiver);
+      if (callbackState === void 0) {
+        callbackState = { depth: 0, leave: enterRunningState(receiver) };
+        activeArrayCallbacks.set(receiver, callbackState);
+      }
+      callbackState.depth += 1;
+      try {
+        const result2 = await callArrayMethodUnlocked(value, methodName, args, options, stack);
+        return result2 === value ? receiver : result2;
+      } finally {
+        callbackState.depth -= 1;
+        if (callbackState.depth === 0) {
+          activeArrayCallbacks.delete(receiver);
+          callbackState.leave();
+        }
       }
     }
+    const result = await callArrayMethodUnlocked(value, methodName, args, options, stack);
+    return result === value ? receiver : result;
+  } finally {
+    options.budget.setRetainedValues(retainedReceiver, void 0);
   }
-  return callArrayMethodUnlocked(value, methodName, args, options, stack);
+}
+async function arrayLikeView(receiver, options) {
+  const rawLength = options.context?.getProperty !== void 0 ? options.context.getProperty(receiver, "length") : getSandboxDataProperty(receiver, "length", options.budget);
+  const number = await sandboxNumber(rawLength, options.budget, options.context);
+  const length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+  const view = new Proxy(/* @__PURE__ */ Object.create(null), {
+    get: (_target, key3) => {
+      options.budget.visitNode();
+      if (key3 === "length") return length;
+      if (typeof key3 !== "string") return void 0;
+      return options.context?.getProperty !== void 0 ? options.context.getProperty(receiver, key3) : getSandboxDataProperty(receiver, key3, options.budget);
+    },
+    has: (_target, key3) => {
+      options.budget.visitNode();
+      if (typeof key3 === "string" && options.hasProperty !== void 0) return options.hasProperty(receiver, key3);
+      for (let current = receiver; current !== null; current = getSandboxPrototype(current, options.budget)) {
+        options.budget.visitNode();
+        if (Object.hasOwn(current, key3)) return true;
+      }
+      return false;
+    },
+    set: (_target, key3, entry) => {
+      options.budget.visitNode();
+      if (typeof key3 !== "string") throw new TypeError("Array indices must be string keys.");
+      if (options.setProperty !== void 0) options.setProperty(receiver, key3, entry);
+      else if (!Reflect.set(receiver, key3, entry)) throw new TypeError(`Cannot assign property '${key3}'.`);
+      return true;
+    },
+    deleteProperty: (_target, key3) => {
+      options.budget.visitNode();
+      if (typeof key3 === "string" && options.deleteProperty !== void 0) return options.deleteProperty(receiver, key3);
+      return Reflect.deleteProperty(receiver, key3);
+    }
+  });
+  arrayLikeSources.set(view, receiver);
+  return view;
 }
 async function callArrayMethodUnlocked(value, methodName, args, options, stack) {
   switch (methodName) {
@@ -144031,11 +144239,21 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       return Reflect.apply(Array.prototype.lastIndexOf, value, [...args]);
     case "join":
       return options.budget.allocateString(Reflect.apply(Array.prototype.join, value, [...args]));
-    case "slice":
-      return budgetProducedValue(
-        Reflect.apply(Array.prototype.slice, value, [...args]),
-        options.budget
-      );
+    case "slice": {
+      const length = value.length;
+      const start = toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context));
+      const end = args[1] === void 0 ? length : toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context));
+      const first = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+      const final = end < 0 ? Math.max(length + end, 0) : Math.min(end, length);
+      const count = Math.max(final - first, 0);
+      options.budget.allocateArrayLength(count);
+      const result = new Array(count);
+      for (let index = 0; index < count; index += 1) {
+        options.budget.visitNode();
+        if (first + index in value) result[index] = value[first + index];
+      }
+      return budgetProducedValue(result, options.budget);
+    }
     case "concat":
       return budgetProducedValue(
         Reflect.apply(Array.prototype.concat, value, [...args]),
@@ -144062,7 +144280,7 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       );
     case "sort":
       if (args[0] === void 0) {
-        value.sort();
+        Reflect.apply(Array.prototype.sort, value, []);
         budgetProducedValue(value, options.budget);
         return value;
       }
@@ -144070,11 +144288,17 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       budgetProducedValue(value, options.budget);
       return value;
     case "reverse":
-      value.reverse();
+      Reflect.apply(Array.prototype.reverse, value, []);
       budgetProducedValue(value, options.budget);
       return value;
     case "toSorted": {
-      const result = Array.from(value);
+      const length = value.length;
+      options.budget.allocateArrayLength(length);
+      const result = new Array(length);
+      for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
+        result[index] = value[index];
+      }
       if (args[0] === void 0) {
         result.sort();
       } else {
@@ -144083,13 +144307,29 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       return budgetProducedValue(result, options.budget);
     }
     case "toReversed": {
-      const result = Array.from(value);
-      result.reverse();
+      const length = value.length;
+      options.budget.allocateArrayLength(length);
+      const result = new Array(length);
+      for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
+        result[index] = value[length - index - 1];
+      }
       return budgetProducedValue(result, options.budget);
     }
     case "toSpliced": {
-      const result = Array.from(value);
-      Reflect.apply(Array.prototype.splice, result, [...args]);
+      const length = value.length;
+      const start = toIntegerOrInfinity(await sandboxNumber(args[0], options.budget, options.context));
+      const first = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+      const inserted = Math.max(args.length - 2, 0);
+      const deleted = args.length === 0 ? 0 : args.length === 1 ? length - first : Math.min(Math.max(toIntegerOrInfinity(await sandboxNumber(args[1], options.budget, options.context)), 0), length - first);
+      const resultLength = length + inserted - deleted;
+      if (resultLength > Number.MAX_SAFE_INTEGER) throw new TypeError("Array-like length exceeds the safe integer limit.");
+      options.budget.allocateArrayLength(resultLength);
+      const result = new Array(resultLength);
+      for (let index = 0; index < resultLength; index += 1) {
+        options.budget.visitNode();
+        result[index] = index < first ? value[index] : index < first + inserted ? args[index - first + 2] : value[index - inserted + deleted];
+      }
       return budgetProducedValue(result, options.budget);
     }
     case "with": {
@@ -144103,39 +144343,42 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
       const result = [];
       for (let position = 0; position < length; position += 1) {
         options.budget.visitNode();
-        result[position] = position === actualIndex ? args[1] : Object.hasOwn(value, position) ? value[position] : void 0;
+        result[position] = position === actualIndex ? args[1] : Array.isArray(value) && !Object.hasOwn(value, position) ? void 0 : value[position];
       }
       return budgetProducedValue(result, options.budget);
     }
     case "push": {
-      appendArrayValues(value, args);
-      const nextLength = value.length;
+      const nextLength = appendArrayValues(value, args);
       budgetProducedValue(value, options.budget);
       return nextLength;
     }
     case "pop":
-      return budgetProducedValue(value.pop(), options.budget);
+      return budgetProducedValue(Reflect.apply(Array.prototype.pop, value, []), options.budget);
     case "shift":
-      return budgetProducedValue(value.shift(), options.budget);
+      return budgetProducedValue(Reflect.apply(Array.prototype.shift, value, []), options.budget);
     case "unshift": {
-      prependArrayValues(value, args);
-      const nextLength = value.length;
+      const nextLength = prependArrayValues(value, args);
       budgetProducedValue(value, options.budget);
       return nextLength;
     }
   }
 }
 function appendArrayValues(target, values) {
+  let length = target.length;
+  if (length + values.length > Number.MAX_SAFE_INTEGER) throw new TypeError("Array-like length exceeds the safe integer limit.");
   for (const value of values) {
-    target.push(value);
+    target[length++] = value;
   }
+  target.length = length;
+  return length;
 }
 function prependArrayValues(target, values) {
   const originalLength = target.length;
-  target.length = originalLength + values.length;
-  for (let index = originalLength - 1; index >= 0; index -= 1) {
+  const length = originalLength + values.length;
+  if (length > Number.MAX_SAFE_INTEGER) throw new TypeError("Array-like length exceeds the safe integer limit.");
+  for (let index = values.length === 0 ? -1 : originalLength - 1; index >= 0; index -= 1) {
     const targetIndex = index + values.length;
-    if (Object.hasOwn(target, index)) {
+    if (index in target) {
       target[targetIndex] = target[index];
     } else {
       delete target[targetIndex];
@@ -144144,6 +144387,8 @@ function prependArrayValues(target, values) {
   for (let index = 0; index < values.length; index += 1) {
     target[index] = values[index];
   }
+  target.length = length;
+  return length;
 }
 function isCallbackArrayMethod(methodName) {
   return methodName === "map" || methodName === "filter" || methodName === "find" || methodName === "findIndex" || methodName === "findLast" || methodName === "findLastIndex" || methodName === "some" || methodName === "every" || methodName === "reduce" || methodName === "reduceRight" || methodName === "forEach" || methodName === "flatMap" || methodName === "sort";
@@ -144159,6 +144404,7 @@ function getRequiredCallback(methodName, value) {
 }
 async function mapArray(value, callback, options, stack, thisValue) {
   const length = value.length;
+  options.budget.allocateArrayLength(length);
   const result = new Array(length);
   options.budget.setRetainedValues(result, () => [result]);
   try {
@@ -144304,7 +144550,7 @@ async function reduceFromLeft(value, callback, accumulator, startIndex, length,
       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, arrayLikeSources.get(value) ?? value], stack);
     }
     return current;
   } finally {
@@ -144321,7 +144567,7 @@ async function reduceFromRight(value, callback, accumulator, startIndex, length,
       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, arrayLikeSources.get(value) ?? value], stack);
     }
     return current;
   } finally {
@@ -144444,7 +144690,7 @@ async function compareEntries(left, right, comparator, options, 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);
+  return options.callClosure(callback, [value, index, arrayLikeSources.get(array) ?? array], stack, thisValue);
 }
 function findNextDefinedIndex(value, startIndex, direction, length, budget) {
   for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
@@ -144456,6 +144702,7 @@ function findNextDefinedIndex(value, startIndex, direction, length, budget) {
   return -1;
 }
 function budgetProducedValue(value, budget) {
+  if (typeof value === "object" && value !== null) value = arrayLikeSources.get(value) ?? value;
   allocateProducedValue(value, budget, /* @__PURE__ */ new WeakSet());
   return value;
 }
@@ -144519,12 +144766,15 @@ function toIntegerOrInfinity(value) {
   }
   return Math.trunc(number);
 }
-var activeArrayCallbacks, arrayMethodNames;
+var arrayLikeSources, activeArrayCallbacks, arrayMethodNames;
 var init_array = __esm({
   "packages/safe-js/src/interp/methods/array.ts"() {
     "use strict";
     init_values();
     init_running_state();
+    init_object_model();
+    init_string_coercion();
+    arrayLikeSources = /* @__PURE__ */ new WeakMap();
     activeArrayCallbacks = /* @__PURE__ */ new WeakMap();
     arrayMethodNames = /* @__PURE__ */ new Set([
       "map",
@@ -144771,14 +145021,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(([key3, value]) => [key3, value]),
-        options.budget
-      );
+      return createSandboxCollectionIterator(target, methodName);
   }
 }
 var mapMethodNames;
@@ -144788,6 +145033,7 @@ var init_map = __esm({
     init_values();
     init_running_state();
     init_collection_callback();
+    init_collection_iterator();
     mapMethodNames = /* @__PURE__ */ new Set([
       "get",
       "set",
@@ -144810,68 +145056,48 @@ function getNumberMember(property, budget) {
   return createSandboxClosure({
     sandbox: true,
     name: `Number#${property}`,
-    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget)
+    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget, context)
   });
 }
 function isNumberMethodName(property) {
   return typeof property === "string" && numberMethodNames.has(property);
 }
-function callNumberMethod(value, methodName, args, budget) {
+function callNumberMethod(value, methodName, args, budget, context) {
   if (typeof value !== "number") {
     throw new TypeError(`Number#${methodName} requires a number receiver.`);
   }
-  return budget.allocateString(callNativeNumberMethod(value, methodName, args));
-}
-function callNativeNumberMethod(value, methodName, args) {
-  switch (methodName) {
-    case "toString":
-      return value.toString(asValidatedRadix(args[0]));
-    case "toExponential":
-      return args[0] === void 0 ? value.toExponential() : value.toExponential(asValidatedFractionDigits(args[0], methodName));
-    case "toFixed":
-      return value.toFixed(asValidatedFractionDigits(args[0], methodName));
-    case "toPrecision":
-      return args[0] === void 0 ? value.toPrecision() : value.toPrecision(asValidatedPrecision(args[0]));
-  }
-}
-function asValidatedRadix(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const radix = toIntegerOrInfinity2(value);
-  if (radix < 2 || radix > 36) {
-    throw new RangeError("Number#toString radix must be between 2 and 36.");
-  }
-  return radix;
-}
-function asValidatedFractionDigits(value, methodName) {
-  const digits = toIntegerOrInfinity2(value);
-  if (digits < 0 || digits > 100) {
-    throw new RangeError(`Number#${methodName} digits must be between 0 and 100.`);
+  const argument = args[0];
+  if (argument !== null && typeof argument === "object") {
+    return formatObjectArgument(value, methodName, argument, budget, context);
   }
-  return digits;
+  return formatNumber3(value, methodName, argument === void 0 ? void 0 : Number(argument), budget);
 }
-function asValidatedPrecision(value) {
-  const precision = toIntegerOrInfinity2(value);
-  if (precision < 1 || precision > 100) {
-    throw new RangeError("Number#toPrecision precision must be between 1 and 100.");
+async function formatObjectArgument(value, methodName, argument, budget, context) {
+  const retainedArgument = {};
+  budget.setRetainedValues(retainedArgument, () => [argument]);
+  try {
+    const number = await sandboxNumber(argument, budget, context);
+    return formatNumber3(value, methodName, number, budget);
+  } finally {
+    budget.setRetainedValues(retainedArgument, void 0);
   }
-  return precision;
 }
-function toIntegerOrInfinity2(value) {
-  const number = Number(value);
-  if (Number.isNaN(number) || Object.is(number, 0) || Object.is(number, -0)) {
-    return 0;
-  }
-  if (!Number.isFinite(number)) {
-    return number;
+function formatNumber3(value, methodName, argument, budget) {
+  let result;
+  try {
+    result = value[methodName](argument);
+  } catch (error3) {
+    if (!(error3 instanceof RangeError)) throw error3;
+    const detail = methodName === "toString" ? "radix must be between 2 and 36." : methodName === "toPrecision" ? "precision must be between 1 and 100." : "digits must be between 0 and 100.";
+    throw new RangeError(`Number#${methodName} ${detail}`);
   }
-  return Math.trunc(number);
+  return budget.allocateString(result);
 }
 var numberMethodNames;
 var init_number = __esm({
   "packages/safe-js/src/interp/methods/number.ts"() {
     "use strict";
+    init_string_coercion();
     init_values();
     numberMethodNames = /* @__PURE__ */ new Set([
       "toExponential",
@@ -145409,12 +145635,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);
   }
 }
 var setMethodNames;
@@ -145424,6 +145646,7 @@ var init_set = __esm({
     init_values();
     init_running_state();
     init_collection_callback();
+    init_collection_iterator();
     setMethodNames = /* @__PURE__ */ new Set([
       "add",
       "has",
@@ -145616,6 +145839,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";
@@ -145629,6 +145853,7 @@ var init_object2 = __esm({
     init_exceptions();
     init_float32();
     init_host_capabilities();
+    init_collection_iterator();
     init_object_model();
     init_string_coercion();
     init_values();
@@ -145721,7 +145946,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;
@@ -145796,6 +146021,30 @@ var init_collections = __esm({
   }
 });
 
+// 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);
+    }
+  });
+}
+var init_collection_iterator2 = __esm({
+  "packages/safe-js/src/interp/methods/collection-iterator.ts"() {
+    "use strict";
+    init_collection_iterator();
+    init_values();
+  }
+});
+
 // packages/safe-js/src/interp/globals/float32array.ts
 function createFloat32ArrayGlobal(budget) {
   const constructor = createSandboxClosure({
@@ -146954,6 +147203,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 [key3, entry] of value.entries) {
       if (!isRestorableBindingValue(key3, seen) || !isRestorableBindingValue(entry, seen)) {
@@ -147196,7 +147448,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);
       }
     }
@@ -147244,7 +147496,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`);
   }
@@ -147543,7 +147795,7 @@ function createLoopIterationContext(context, scope) {
       if (context.activeLoopIterations.size === 0) return snapshot2;
       snapshot2.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}`;
           snapshot2.bindings[bindingName] = iteration.values;
           snapshot2.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
@@ -147670,7 +147922,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`);
   }
@@ -147880,6 +148132,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);
@@ -147892,6 +148145,7 @@ function getPropertyValue(target, property, context) {
 function createPatternContext(context, scope = context.scope, evaluate = evaluateNode2) {
   const evaluationContext = { ...context, scope };
   return {
+    budget: context.budget,
     evaluate: (node) => evaluate(node, evaluationContext),
     toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(evaluationContext)),
     getProperty: (value, key3) => getPropertyValue(value, key3, evaluationContext),
@@ -148399,7 +148653,7 @@ function hasSandboxProperty(value, key3, context) {
   while (typeof current === "object" && current !== null) {
     if (isGuestHostObject(current)) return hasHostObjectMember(current, key3);
     if (hasOwnSandboxProperty(current, key3, 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, key3, context) !== void 0;
     }
     current = getSandboxPrototype(current, context.budget);
@@ -148609,7 +148863,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)];
@@ -148724,7 +148978,7 @@ async function evaluateNumberMethodCall(node, target, methodName, context) {
     return {
       kind: "normal",
       hasValue: true,
-      value: callNumberMethod(target, methodName, args.value, context.budget)
+      value: await callNumberMethod(target, methodName, args.value, context.budget, createCoercionContext(context))
     };
   } catch (error3) {
     if (isFatalSandboxError(error3)) {
@@ -148736,6 +148990,10 @@ async function evaluateNumberMethodCall(node, target, methodName, context) {
 function createArrayMethodOptions(context) {
   return {
     budget: context.budget,
+    context: createCoercionContext(context),
+    hasProperty: (value, property) => hasSandboxProperty(value, property, context),
+    setProperty: (value, property, entry) => setSandboxProperty(value, property, entry, context.budget),
+    deleteProperty: deleteSandboxProperty,
     callClosure: (closure, args, stack, thisValue) => invokeSandboxClosure(closure, args, context, stack, void 0, thisValue)
   };
 }
@@ -148824,7 +149082,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.");
   }
@@ -148894,9 +149152,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();
@@ -148960,6 +149215,8 @@ var init_interpreter = __esm({
     init_error();
     init_object2();
     init_collections();
+    init_collection_iterator();
+    init_collection_iterator2();
     init_float32array2();
     init_float32();
     init_date();
@@ -150815,8 +151072,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;
@@ -150842,6 +151099,7 @@ function assertStructuredCloneable(value, seen) {
 var init_misc = __esm({
   "packages/safe-js/src/interp/globals/misc.ts"() {
     "use strict";
+    init_collection_iterator();
     init_graph_depth();
     init_values();
   }
@@ -150951,7 +151209,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.");
           }
@@ -151214,7 +151472,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;
@@ -152823,6 +153081,7 @@ var init_serialize = __esm({
   "packages/safe-js/src/snapshot/serialize.ts"() {
     "use strict";
     init_hash();
+    init_collection_iterator();
     init_object_model();
     init_shape();
     init_graph_depth();
@@ -152885,6 +153144,16 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
       throw new TypeError("Invalid replay input capability path.");
     let value = current;
     for (const key3 of path193) {
+      if (isSandboxCollectionIterator(value)) {
+        if (key3 === "<collection>") value = collectionIteratorState(value).collection;
+        else {
+          const property = JSON.parse(key3);
+          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] = key3.split(":");
         const index = Number(ordinal);
@@ -152945,11 +153214,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 key3 of ["bindings", "imports"]) {
-    if (values[key3] === null || typeof values[key3] !== "object" || Array.isArray(values[key3]) || isSandboxClosure(values[key3]) || isSandboxPromise(values[key3]) || isSandboxMap(values[key3]) || isSandboxSet(values[key3]))
+    if (values[key3] === null || typeof values[key3] !== "object" || Array.isArray(values[key3]) || isSandboxClosure(values[key3]) || isSandboxPromise(values[key3]) || isSandboxCollectionIterator(values[key3]) || isSandboxMap(values[key3]) || isSandboxSet(values[key3]))
       throw new TypeError(`Invalid replay input ${key3}.`);
   }
   if (values.entryPointArgs !== void 0 && !Array.isArray(values.entryPointArgs))
@@ -152959,6 +153228,7 @@ var validationPromise;
 var init_replay_inputs = __esm({
   "packages/safe-js/src/snapshot/replay-inputs.ts"() {
     "use strict";
+    init_collection_iterator();
     init_values();
     init_replay_data();
     init_compile_guard();
@@ -158976,11 +159246,11 @@ async function resolveWorkflowTasksOptions(options) {
   };
 }
 function readGateStates(frontmatter) {
-  const states = asRecord6(frontmatter.states);
-  if (states === void 0) {
+  const states2 = asRecord6(frontmatter.states);
+  if (states2 === void 0) {
     return [];
   }
-  return Object.entries(states).filter(([, definition]) => asRecord6(definition)?.gate === true).map(([name]) => name);
+  return Object.entries(states2).filter(([, definition]) => asRecord6(definition)?.gate === true).map(([name]) => name);
 }
 async function readWorkflowFrontmatter(workflowPath) {
   const workflowContent = await readWorkflow(workflowPath);
@@ -159011,11 +159281,11 @@ function readTaskListOptions(frontmatter, workflowPath) {
   }
   return resolved;
 }
-function createAnyToAnyStateMachine(states) {
+function createAnyToAnyStateMachine(states2) {
   return {
-    initial: states[0],
-    states,
-    events: Object.fromEntries(states.map((state) => [state, { from: "*", to: state }]))
+    initial: states2[0],
+    states: states2,
+    events: Object.fromEntries(states2.map((state) => [state, { from: "*", to: state }]))
   };
 }
 function parseProject(value) {
@@ -159036,9 +159306,9 @@ function parseProject(value) {
 }
 function resolveRequiredStates(statesOption, frontmatter) {
   if (statesOption !== void 0) {
-    const states = parseStatesCsv(statesOption);
-    if (states.length > 0) {
-      return states;
+    const states2 = parseStatesCsv(statesOption);
+    if (states2.length > 0) {
+      return states2;
     }
     throw new TasksOptionsError(
       "missing_required_states",
@@ -159088,8 +159358,8 @@ function readLegacyTopLevelStates(frontmatter) {
   ]);
 }
 function readDeclaredStates(value) {
-  const states = asRecord6(value);
-  return states === void 0 ? [] : Object.keys(states);
+  const states2 = asRecord6(value);
+  return states2 === void 0 ? [] : Object.keys(states2);
 }
 function readTasksRepo(frontmatter) {
   const tasks = asRecord6(getOwnEntry37(frontmatter, "tasks"));