poe-code 14.0.51 → 14.0.53

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,10 +1,19 @@
 import { Budget } from "../budget.js";
-import { type SandboxArray, type SandboxClosure, type SandboxValue } from "../values.js";
+import { type SandboxArray, type SandboxCallContext, type SandboxClosure, type SandboxObject, type SandboxValue } from "../values.js";
+type ArrayLikeValue = SandboxArray | (SandboxObject & {
+    [index: number]: SandboxValue;
+    length: number;
+});
 export type ArrayMethodName = "map" | "filter" | "find" | "findIndex" | "findLast" | "findLastIndex" | "some" | "every" | "reduce" | "reduceRight" | "forEach" | "flatMap" | "flat" | "includes" | "indexOf" | "lastIndexOf" | "join" | "slice" | "concat" | "splice" | "fill" | "copyWithin" | "at" | "sort" | "reverse" | "toSorted" | "toReversed" | "toSpliced" | "with" | "push" | "pop" | "shift" | "unshift";
 export type ArrayMethodOptions = {
     budget: Budget;
+    context?: SandboxCallContext;
+    hasProperty?: (value: SandboxValue, property: string) => boolean;
+    setProperty?: (value: SandboxValue, property: string, entry: SandboxValue) => void;
+    deleteProperty?: (value: SandboxValue, property: string | number) => boolean;
     callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue?: SandboxValue) => Promise<SandboxValue>;
 };
-export declare function getArrayMember(value: SandboxArray, property: string | number, options: ArrayMethodOptions): SandboxValue | undefined;
+export declare function getArrayMember(value: ArrayLikeValue, property: string | number, options: ArrayMethodOptions): SandboxValue | undefined;
 export declare function isArrayMethodName(property: string | number): property is ArrayMethodName;
-export declare function callArrayMethod(value: SandboxArray, methodName: ArrayMethodName, args: readonly SandboxValue[], options: ArrayMethodOptions, stack?: readonly string[]): Promise<SandboxValue>;
+export declare function callArrayMethod(receiver: SandboxValue, methodName: ArrayMethodName, args: readonly SandboxValue[], options: ArrayMethodOptions, stack?: readonly string[]): Promise<SandboxValue>;
+export {};