poe-code 14.0.51 → 14.0.53

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

@@ -1,5 +1,8 @@
 import { createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet } from "../values.js";
 import { assertCollectionMutable, enterRunningState } from "../running-state.js";
+import { getSandboxDataProperty, getSandboxPrototype } from "../object-model.js";
+import { sandboxNumber } from "../string-coercion.js";
+const arrayLikeSources = new WeakMap();
 const activeArrayCallbacks = new WeakMap();
 const arrayMethodNames = new Set([
     "map",
@@ -51,7 +54,7 @@ export 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 undefined;
@@ -69,29 +72,94 @@ function getArrayIndex(property) {
 export function isArrayMethodName(property) {
     return typeof property === "string" && arrayMethodNames.has(property);
 }
-export async function callArrayMethod(value, methodName, args, options, stack = []) {
-    if (isMutatingArrayMethod(methodName)) {
-        assertCollectionMutable(value);
-    }
-    if (isCallbackArrayMethod(methodName)) {
-        let callbackState = activeArrayCallbacks.get(value);
-        if (callbackState === undefined) {
-            callbackState = { depth: 0, leave: enterRunningState(value) };
-            activeArrayCallbacks.set(value, callbackState);
-        }
-        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();
+export async function callArrayMethod(receiver, methodName, args, options, stack = []) {
+    if (receiver === null || receiver === undefined)
+        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);
+        }
+        if (isCallbackArrayMethod(methodName)) {
+            let callbackState = activeArrayCallbacks.get(receiver);
+            if (callbackState === undefined) {
+                callbackState = { depth: 0, leave: enterRunningState(receiver) };
+                activeArrayCallbacks.set(receiver, callbackState);
+            }
+            callbackState.depth += 1;
+            try {
+                const result = await callArrayMethodUnlocked(value, methodName, args, options, stack);
+                return result === value ? receiver : result;
+            }
+            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;
     }
-    return callArrayMethodUnlocked(value, methodName, args, options, stack);
+    finally {
+        options.budget.setRetainedValues(retainedReceiver, undefined);
+    }
+}
+async function arrayLikeView(receiver, options) {
+    const rawLength = options.context?.getProperty !== undefined
+        ? 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);
+    // The view is internal only: callbacks, results, and accounting keep the guest receiver.
+    const view = new Proxy(Object.create(null), {
+        get: (_target, key) => {
+            options.budget.visitNode();
+            if (key === "length")
+                return length;
+            if (typeof key !== "string")
+                return undefined;
+            return options.context?.getProperty !== undefined
+                ? options.context.getProperty(receiver, key)
+                : getSandboxDataProperty(receiver, key, options.budget);
+        },
+        has: (_target, key) => {
+            options.budget.visitNode();
+            if (typeof key === "string" && options.hasProperty !== undefined)
+                return options.hasProperty(receiver, key);
+            for (let current = receiver; current !== null; current = getSandboxPrototype(current, options.budget)) {
+                options.budget.visitNode();
+                if (Object.hasOwn(current, key))
+                    return true;
+            }
+            return false;
+        },
+        set: (_target, key, entry) => {
+            options.budget.visitNode();
+            if (typeof key !== "string")
+                throw new TypeError("Array indices must be string keys.");
+            if (options.setProperty !== undefined)
+                options.setProperty(receiver, key, entry);
+            else if (!Reflect.set(receiver, key, entry))
+                throw new TypeError(`Cannot assign property '${key}'.`);
+            return true;
+        },
+        deleteProperty: (_target, key) => {
+            options.budget.visitNode();
+            if (typeof key === "string" && options.deleteProperty !== undefined)
+                return options.deleteProperty(receiver, key);
+            return Reflect.deleteProperty(receiver, key);
+        }
+    });
+    arrayLikeSources.set(view, receiver);
+    return view;
 }
 async function callArrayMethodUnlocked(value, methodName, args, options, stack) {
     switch (methodName) {
@@ -130,8 +198,22 @@ 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] === undefined ? 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]), options.budget);
         case "splice": {
@@ -152,7 +234,7 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
             return budgetProducedValue(Reflect.apply(Array.prototype.at, value, [...args]), options.budget);
         case "sort":
             if (args[0] === undefined) {
-                value.sort();
+                Reflect.apply(Array.prototype.sort, value, []);
                 budgetProducedValue(value, options.budget);
                 return value;
             }
@@ -160,11 +242,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] === undefined) {
                 result.sort();
             }
@@ -174,13 +262,33 @@ 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": {
@@ -197,41 +305,46 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
                 result[position] =
                     position === actualIndex
                         ? args[1]
-                        : Object.hasOwn(value, position)
-                            ? value[position]
-                            : undefined;
+                        : Array.isArray(value) && !Object.hasOwn(value, position)
+                            ? undefined
+                            : 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 {
@@ -241,6 +354,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" ||
@@ -276,6 +391,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 {
@@ -415,7 +531,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;
     }
@@ -433,7 +549,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;
     }
@@ -552,7 +668,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) {
@@ -564,6 +680,8 @@ 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, new WeakSet());
     return value;
 }

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { Budget } from "../budget.js";
-import { type SandboxValue } from "../values.js";
+import { type SandboxCallContext, type SandboxValue } from "../values.js";
 export type NumberMethodName = "toExponential" | "toFixed" | "toPrecision" | "toString";
 export declare function getNumberMember(property: string | number, budget: Budget): SandboxValue | undefined;
 export declare function isNumberMethodName(property: string | number): property is NumberMethodName;
-export declare function callNumberMethod(value: SandboxValue, methodName: NumberMethodName, args: readonly SandboxValue[], budget: Budget): string;
+export declare function callNumberMethod(value: SandboxValue, methodName: NumberMethodName, args: readonly SandboxValue[], budget: Budget, context?: SandboxCallContext): string | Promise<string>;

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

@@ -1,3 +1,4 @@
+import { sandboxNumber } from "../string-coercion.js";
 import { createSandboxClosure } from "../values.js";
 const numberMethodNames = new Set([
     "toExponential",
@@ -12,65 +13,45 @@ export 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)
     });
 }
 export function isNumberMethodName(property) {
     return typeof property === "string" && numberMethodNames.has(property);
 }
-export function callNumberMethod(value, methodName, args, budget) {
+export 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] === undefined
-                ? value.toExponential()
-                : value.toExponential(asValidatedFractionDigits(args[0], methodName));
-        case "toFixed":
-            return value.toFixed(asValidatedFractionDigits(args[0], methodName));
-        case "toPrecision":
-            return args[0] === undefined
-                ? value.toPrecision()
-                : value.toPrecision(asValidatedPrecision(args[0]));
-    }
-}
-function asValidatedRadix(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    const radix = toIntegerOrInfinity(value);
-    if (radix < 2 || radix > 36) {
-        throw new RangeError("Number#toString radix must be between 2 and 36.");
+    const argument = args[0];
+    if (argument !== null && typeof argument === "object") {
+        return formatObjectArgument(value, methodName, argument, budget, context);
     }
-    return radix;
+    return formatNumber(value, methodName, argument === undefined ? undefined : Number(argument), budget);
 }
-function asValidatedFractionDigits(value, methodName) {
-    const digits = toIntegerOrInfinity(value);
-    if (digits < 0 || digits > 100) {
-        throw new RangeError(`Number#${methodName} digits must be between 0 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 formatNumber(value, methodName, number, budget);
     }
-    return digits;
-}
-function asValidatedPrecision(value) {
-    const precision = toIntegerOrInfinity(value);
-    if (precision < 1 || precision > 100) {
-        throw new RangeError("Number#toPrecision precision must be between 1 and 100.");
+    finally {
+        budget.setRetainedValues(retainedArgument, undefined);
     }
-    return precision;
 }
-function toIntegerOrInfinity(value) {
-    const number = Number(value);
-    if (Number.isNaN(number) || Object.is(number, 0) || Object.is(number, -0)) {
-        return 0;
+function formatNumber(value, methodName, argument, budget) {
+    let result;
+    try {
+        result = value[methodName](argument);
     }
-    if (!Number.isFinite(number)) {
-        return number;
+    catch (error) {
+        if (!(error instanceof RangeError))
+            throw error;
+        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);
 }

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

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

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

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

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

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

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

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

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

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

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

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