poe-code 14.0.51 → 14.0.52

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

@@ -1,4 +1,6 @@
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
+import { isSandboxMap, isSandboxSet, sandboxMapBrand, sandboxSetBrand } from "./collection-brands.js";
+import { collectionIteratorState, isSandboxCollectionIterator, restoreSandboxCollectionIterator, snapshotCollectionIterator } from "./collection-iterator.js";
 import { copyNativeDate, exportDate, isSandboxDate } from "./date.js";
 import { getHostObjectKeys, getHostObjectMember, hasHostObjectMember, measureHostObjectData, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
 import { types as nodeTypes } from "node:util";
@@ -14,13 +16,12 @@ import { sandboxErrorTypes } from "../error/shape.js";
 import { getGuestFunctionProperties, getSandboxPrototype, hasGuestObjectState, hasManagedDescriptors, isGuestClosure, registerGuestClosure } from "./object-model.js";
 import { copySandboxArgumentProperties, createSandboxArguments, getSandboxArgumentEntries, isSandboxArguments } from "./arguments.js";
 export { createSandboxArguments, isSandboxArguments } from "./arguments.js";
+export { isSandboxMap, isSandboxSet } from "./collection-brands.js";
 const sandboxClosureBrand = Symbol("SandboxClosure");
 const sandboxGeneratorBrand = Symbol("SandboxGenerator");
-const sandboxMapBrand = Symbol("SandboxMap");
 const sandboxPromiseBrand = Symbol("SandboxPromise");
 const sandboxRegexBrand = Symbol("SandboxRegex");
 const sandboxRegexPattern = Symbol("SandboxRegexPattern");
-const sandboxSetBrand = Symbol("SandboxSet");
 const sandboxRetainedValues = Symbol("SandboxRetainedValues");
 export function createSandboxClosure(input) {
     const closure = {
@@ -195,15 +196,9 @@ export function getSandboxRegexPattern(regex) {
 export function isSandboxClosure(value) {
     return typeof value === "object" && value !== null && sandboxClosureBrand in value;
 }
-export function isSandboxMap(value) {
-    return typeof value === "object" && value !== null && sandboxMapBrand in value;
-}
 export function isSandboxPromise(value) {
     return typeof value === "object" && value !== null && sandboxPromiseBrand in value;
 }
-export function isSandboxSet(value) {
-    return typeof value === "object" && value !== null && sandboxSetBrand in value;
-}
 export function isSandboxGenerator(value) {
     return typeof value === "object" && value !== null && sandboxGeneratorBrand in value;
 }
@@ -216,9 +211,14 @@ export function deepCopyToSandbox(value) {
     });
 }
 export function cloneSandboxValue(value) {
-    return copyToSandbox(value, {
-        seen: new WeakMap()
+    const initializeIterators = [];
+    const copy = copyToSandbox(value, {
+        seen: new WeakMap(),
+        initializeIterators
     }, "<root>", true);
+    for (const initialize of initializeIterators)
+        initialize();
+    return copy;
 }
 export function allocateProducedSandboxValue(value, budget) {
     allocateSandboxValue(value, budget, new WeakSet());
@@ -289,6 +289,15 @@ export function measureSandboxData(values, options = {}) {
             }
             return;
         }
+        if (isSandboxCollectionIterator(value)) {
+            visit(collectionIteratorState(value).collection, depth + 1);
+            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+                usage += key.length + 1;
+                if ("value" in descriptor)
+                    visit(descriptor.value, depth + 1);
+            }
+            return;
+        }
         if (isSandboxSet(value)) {
             usage += value.values.size;
             for (const entry of value.values)
@@ -409,6 +418,26 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
         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 !== undefined)
+            return existing;
+        const snapshot = snapshotCollectionIterator(value);
+        const copy = restoreSandboxCollectionIterator({ ...snapshot, collection: undefined, index: 0, exhausted: true });
+        state.seen.set(value, copy);
+        const collection = copyToSandbox(snapshot.collection, state, `${path}.<collection>`, true, depth + 1);
+        if (collection !== undefined && !isSandboxMap(collection) && !isSandboxSet(collection))
+            throw new TypeError("Invalid cloned collection iterator source.");
+        state.initializeIterators.push(() => { restoreSandboxCollectionIterator({ ...snapshot, collection }, copy); });
+        for (const entry of getEnumerableObjectEntries(value, path)) {
+            defineOwnDataProperty(copy, entry.key, copyToSandbox(entry.value, state, joinPath(path, entry.key), true, depth + 1));
+        }
+        return copy;
+    }
     if (typeof value === "object" && value !== null && hasGuestObjectState(value)) {
         throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
     }
@@ -634,6 +663,9 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     if (isSandboxGenerator(value)) {
         throw new TypeError("Sandbox generators cannot cross into host values.");
     }
+    if (isSandboxCollectionIterator(value)) {
+        throw new TypeError("Sandbox collection iterators cannot cross into host values.");
+    }
     if (isSandboxRegex(value)) {
         throw new TypeError("Invalid sandbox RegExp brand.");
     }

package/packages/safe-js/dist/snapshot/replay-data.d.ts

@@ -1,3 +1,4 @@
+import { type CollectionIterationMethod } from "../interp/collection-iterator.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { type Float32Data } from "./float32array.js";
 import { type SandboxErrorName } from "../error/shape.js";
@@ -25,6 +26,15 @@ type Properties = Record<string, {
     writable: boolean;
 }>;
 type DataNode = {
+    kind: "collection-iterator";
+    collectionKind: "map" | "set";
+    method: CollectionIterationMethod;
+    collection: Atom;
+    index: number;
+    exhausted: boolean;
+    properties: Properties;
+    extensible: boolean;
+} | {
     kind: "date";
     time: number | null;
 } | (Float32Data<Atom> & {

package/packages/safe-js/dist/snapshot/replay-data.js

@@ -1,4 +1,5 @@
 import { MAX_DATA_DEPTH } from "../graph-depth.js";
+import { isSandboxCollectionIterator, restoreSandboxCollectionIterator, snapshotCollectionIterator } from "../interp/collection-iterator.js";
 import { hasGuestObjectState } from "../interp/object-model.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
@@ -83,6 +84,16 @@ export function encodeReplayData(value, options = {}) {
             }
             nodes[id] = { ...storage, properties, extensible: Object.isExtensible(entry) };
         }
+        else if (isSandboxCollectionIterator(entry)) {
+            const snapshot = snapshotCollectionIterator(entry);
+            const properties = Object.create(null);
+            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(entry))) {
+                if (!("value" in descriptor))
+                    throw new TypeError(`Cannot record replay data accessor '${key}'.`);
+                properties[key] = { value: child(descriptor.value, JSON.stringify(["property", key])), configurable: descriptor.configurable === true, enumerable: descriptor.enumerable === true, writable: descriptor.writable === true };
+            }
+            nodes[id] = { kind: "collection-iterator", collectionKind: snapshot.collectionKind, method: snapshot.method, collection: child(snapshot.collection, "<collection>"), index: snapshot.index, exhausted: snapshot.exhausted, properties, extensible: Object.isExtensible(entry) };
+        }
         else if (isSandboxMap(entry)) {
             nodes[id] = {
                 kind: "map",
@@ -146,6 +157,7 @@ export function decodeReplayData(input, options = {}, parent) {
         const graph = record(input);
         const nodes = list(own(graph, "nodes"));
         const restored = new Map();
+        const initializeIterators = [];
         const decode = (entry, depth = 0) => {
             if (depth > MAX_DATA_DEPTH)
                 throw new TypeError("Replay data exceeds the nesting limit.");
@@ -252,6 +264,24 @@ export function decodeReplayData(input, options = {}, parent) {
                     Object.preventExtensions(result);
                 return result;
             }
+            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 result = restoreSandboxCollectionIterator({ collection: undefined, collectionKind, method, index: 0, exhausted: true });
+                restored.set(id, result);
+                const collection = child(own(node, "collection"));
+                if (collection !== undefined && !isSandboxMap(collection) && !isSandboxSet(collection))
+                    throw new TypeError("Invalid replay collection iterator source.");
+                initializeIterators.push(() => { restoreSandboxCollectionIterator({ collection, collectionKind, method, index, exhausted }, result); });
+                defineProperties(result, record(own(node, "properties")), child);
+                if (!node.extensible)
+                    Object.preventExtensions(result);
+                return result;
+            }
             if (kind === "map") {
                 const result = createSandboxMap();
                 restored.set(id, result);
@@ -320,6 +350,8 @@ export function decodeReplayData(input, options = {}, parent) {
             return result;
         };
         const result = decode(own(graph, "root"));
+        for (const initialize of initializeIterators)
+            initialize();
         if (parent !== undefined)
             compilation.forward(compilation.tickets, parent);
         return result;

package/packages/safe-js/dist/snapshot/replay-inputs.js

@@ -1,3 +1,4 @@
+import { collectionIteratorState, isSandboxCollectionIterator } from "../interp/collection-iterator.js";
 import { createSandboxPromise, isSandboxClosure, isSandboxMap, isSandboxSet, isSandboxPromise } from "../interp/values.js";
 import { decodeReplayData, encodeReplayData } from "./replay-data.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
@@ -41,6 +42,18 @@ export function prepareReplayInputs(current, saved, preparePromise, onCapability
             throw new TypeError("Invalid replay input capability path.");
         let value = current;
         for (const key of path) {
+            if (isSandboxCollectionIterator(value)) {
+                if (key === "<collection>")
+                    value = collectionIteratorState(value).collection;
+                else {
+                    const property = JSON.parse(key);
+                    if (!Array.isArray(property) || property.length !== 2 || property[0] !== "property" || typeof property[1] !== "string")
+                        throw new TypeError("Invalid replay input iterator capability path.");
+                    const descriptor = Object.getOwnPropertyDescriptor(value, property[1]);
+                    value = descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+                }
+                continue;
+            }
             if (isSandboxMap(value)) {
                 const [kind, ordinal] = key.split(":");
                 const index = Number(ordinal);
@@ -104,6 +117,7 @@ function assertReplayInputShape(restored) {
         Array.isArray(restored) ||
         isSandboxClosure(restored) ||
         isSandboxPromise(restored) ||
+        isSandboxCollectionIterator(restored) ||
         isSandboxMap(restored) ||
         isSandboxSet(restored))
         throw new TypeError("Invalid replay inputs.");
@@ -114,6 +128,7 @@ function assertReplayInputShape(restored) {
             Array.isArray(values[key]) ||
             isSandboxClosure(values[key]) ||
             isSandboxPromise(values[key]) ||
+            isSandboxCollectionIterator(values[key]) ||
             isSandboxMap(values[key]) ||
             isSandboxSet(values[key]))
             throw new TypeError(`Invalid replay input ${key}.`);

package/packages/safe-js/dist/snapshot/restore.js

@@ -9,6 +9,8 @@ import { SnapshotMismatchError } from "../restore.js";
 import { Scope, setSandboxProperty } from "../interp/interpreter.js";
 import { getGuestFunctionProperties, getGuestFunctionProperty, getSandboxDataProperty, registerGuestClosure, setSandboxPrototype } from "../interp/object-model.js";
 import { wrapCallerInjectedBindings } from "../interp/host-bridge.js";
+import { restoreSandboxCollectionIterator } from "../interp/collection-iterator.js";
+import { isSandboxMap, isSandboxSet } from "../interp/values.js";
 import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxMap, createSandboxPromise, createSandboxRegex, createSandboxSet, reconcileCompiledValues } from "../interp/values.js";
 import { createGeneratorChannel, restoreGeneratorChannel } from "../interp/generator.js";
 import { hashSource } from "../parse/hash.js";
@@ -45,6 +47,7 @@ export function restore(snapshot, options, owner) {
             throw new Error(`Snapshot references unknown AST node ${snapshot.currentAstNodeId}.`);
         }
         const state = {
+            initializeIterators: [],
             budget,
             compilation,
             heap: snapshot.heap ?? {},
@@ -71,6 +74,8 @@ export function restore(snapshot, options, owner) {
             throw new Error(`Snapshot references unknown scope ${String(currentScopeId)}.`);
         }
         const callStack = snapshot.callStack.map((frame) => restoreCallFrame(frame, state));
+        for (const initialize of state.initializeIterators)
+            initialize();
         reconcileCompiledValues(budget, [
             ...currentScope.retainedValues(),
             ...pendingPromises.flatMap((pending) => Object.values(pending).filter(isSandboxSnapshotValue))
@@ -397,6 +402,17 @@ function restoreHeapValue(id, state) {
             Object.preventExtensions(args);
         return args;
     }
+    if (serialized.kind === "collection-iterator") {
+        const iterator = restoreSandboxCollectionIterator({ collection: undefined, collectionKind: serialized.collectionKind, method: serialized.method, index: 0, exhausted: true });
+        state.heapValueById.set(id, iterator);
+        const collection = deserializeValue(serialized.collection, state);
+        if (collection !== undefined && !isSandboxMap(collection) && !isSandboxSet(collection))
+            throw new TypeError("Invalid collection iterator source.");
+        state.initializeIterators.push(() => { restoreSandboxCollectionIterator({ ...serialized, collection }, iterator); });
+        for (const [key, entry] of Object.entries(serialized.entries))
+            Object.defineProperty(iterator, key, { value: deserializeValue(entry, state), enumerable: true, configurable: true, writable: true });
+        return iterator;
+    }
     if (serialized.kind === "map") {
         const map = createSandboxMap();
         state.heapValueById.set(id, map);

package/packages/safe-js/dist/snapshot/serialize.d.ts

@@ -1,3 +1,4 @@
+import { type CollectionIterationMethod, type SandboxCollectionIterator } from "../interp/collection-iterator.js";
 import { type SandboxErrorName } from "../error/shape.js";
 import { type SerializedArguments } from "./arguments.js";
 import { type SerializedArray } from "./arrays.js";
@@ -41,6 +42,14 @@ export type SerializedReferenceValue = {
     id: number;
 };
 export type SerializedHeapValue = {
+    kind: "collection-iterator";
+    collectionKind: "map" | "set";
+    method: CollectionIterationMethod;
+    collection: SerializedSnapshotValue;
+    index: number;
+    exhausted: boolean;
+    entries: Record<string, SerializedSnapshotValue>;
+} | {
     kind: "date";
     time: number | null;
 } | (Float32Data<SerializedReferenceValue> & {
@@ -75,7 +84,7 @@ export type RuntimePromiseValue = {
     id: SnapshotId;
     promise?: Promise<unknown>;
 };
-export type RuntimeSnapshotValue = Date | Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
+export type RuntimeSnapshotValue = Date | Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | SandboxCollectionIterator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
     [key: string]: RuntimeSnapshotValue;
 };
 export type RuntimeScopeFrame = {

package/packages/safe-js/dist/snapshot/serialize.js

@@ -1,4 +1,5 @@
 import { hashSource } from "../parse/hash.js";
+import { collectionIteratorState, isSandboxCollectionIterator, snapshotCollectionIterator } from "../interp/collection-iterator.js";
 import { hasGuestObjectState } from "../interp/object-model.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
@@ -162,7 +163,7 @@ function serializeValue(value, path, state) {
     if (isSandboxRegex(value)) {
         return { kind: "regex", source: value.source, flags: value.flags, lastIndex: value.lastIndex };
     }
-    if (isSandboxDate(value) || isSandboxMap(value) || isSandboxSet(value) || isFloat32Array(value)) {
+    if (isSandboxDate(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isFloat32Array(value)) {
         const reference = serializeHeapReference(value, path, state);
         if (reference === undefined) {
             throw new TypeError(`Cannot serialize collection without a heap reference at ${path}.`);
@@ -191,7 +192,18 @@ function serializeHeapReference(value, path, state) {
     }
     if (!state.serializedHeapIds.has(id)) {
         state.serializedHeapIds.add(id);
-        if (isSandboxDate(value)) {
+        if (isSandboxCollectionIterator(value)) {
+            const snapshot = snapshotCollectionIterator(value);
+            const entries = Object.create(null);
+            state.heap[String(id)] = {
+                kind: "collection-iterator", collectionKind: snapshot.collectionKind, method: snapshot.method,
+                collection: serializeValue(snapshot.collection, `${path}.<collection>`, state),
+                index: snapshot.index, exhausted: snapshot.exhausted, entries
+            };
+            for (const [key, entry] of Object.entries(value))
+                entries[key] = serializeValue(entry, `${path}.${key}`, state);
+        }
+        else if (isSandboxDate(value)) {
             state.heap[String(id)] = { kind: "date", time: serializedDateTime(value) };
         }
         else if (isFloat32Array(value)) {
@@ -306,6 +318,7 @@ function indexHeapContainers(input) {
             (Array.isArray(value) && requiresArrayEntries(value)) ||
             sandboxErrorTypes.has(value) ||
             isSandboxArguments(value) ||
+            isSandboxCollectionIterator(value) ||
             isSandboxMap(value) ||
             isSandboxSet(value)) {
             heapIds.set(value, nextId);
@@ -327,6 +340,7 @@ function collectContainerStats(value, stats, ancestors) {
         !isSandboxDate(value) &&
         !isFloat32Array(value) &&
         !isSandboxMap(value) &&
+        !isSandboxCollectionIterator(value) &&
         !isSandboxSet(value)) {
         return;
     }
@@ -349,13 +363,15 @@ function collectContainerStats(value, stats, ancestors) {
     }
     stat.expanded = true;
     ancestors.add(value);
-    const entries = isSandboxArguments(value)
-        ? Object.values(Object.getOwnPropertyDescriptors(value)).flatMap((descriptor) => "value" in descriptor ? [descriptor.value] : [])
-        : isSandboxMap(value)
-            ? [...value.entries].flatMap(([key, entry]) => [key, entry])
-            : isSandboxSet(value)
-                ? [...value.values]
-                : Object.values(value);
+    const entries = isSandboxCollectionIterator(value)
+        ? [collectionIteratorState(value).collection, ...Object.values(value)]
+        : isSandboxArguments(value)
+            ? Object.values(Object.getOwnPropertyDescriptors(value)).flatMap((descriptor) => "value" in descriptor ? [descriptor.value] : [])
+            : isSandboxMap(value)
+                ? [...value.entries].flatMap(([key, entry]) => [key, entry])
+                : isSandboxSet(value)
+                    ? [...value.values]
+                    : Object.values(value);
     for (const entry of entries) {
         collectContainerStats(entry, stats, ancestors);
     }

package/packages/safe-js/dist/snapshot/validation.js

@@ -364,6 +364,7 @@ function validateTaggedValue(record, path, state) {
         case "object":
         case "map":
         case "set":
+        case "collection-iterator":
             return;
     }
 }
@@ -407,7 +408,7 @@ function validateGeneratorShape(record, path, state) {
 function validateHeapValue(value, path, state) {
     const record = requireRecord(value, path);
     validateErrorType(record, path);
-    if (!["arguments", "array", "object", "map", "set", "float32array", "date"].includes(String(record.kind)))
+    if (!["arguments", "array", "object", "map", "set", "float32array", "date", "collection-iterator"].includes(String(record.kind)))
         fail("unknownTag", `${path}.kind`, "unknown heap tag");
     validateValue(record, path, 1, state);
     if (record.kind === "arguments")
@@ -431,6 +432,18 @@ function validateHeapValue(value, path, state) {
     }
     if (record.kind === "set")
         requireArray(record.values, `${path}.values`, state);
+    if (record.kind === "collection-iterator") {
+        if (record.collectionKind !== "map" && record.collectionKind !== "set")
+            fail("invalidValue", `${path}.collectionKind`, "invalid iterator brand");
+        if (record.method !== "keys" && record.method !== "values" && record.method !== "entries")
+            fail("invalidValue", `${path}.method`, "invalid iteration method");
+        if (typeof record.exhausted !== "boolean")
+            fail("invalidValue", `${path}.exhausted`, "invalid iterator exhaustion");
+        requireSafeInteger(record.index, `${path}.index`, 0);
+        if (!Object.hasOwn(record, "collection"))
+            fail("invalidValue", `${path}.collection`, "missing iterator source");
+        requireRecord(record.entries, `${path}.entries`);
+    }
 }
 function validateDateRecord(record, path) {
     if (Object.keys(record).length !== 2)