@poe-platform/safe-js 0.1.106 → 0.1.108

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

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

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

@@ -25362,6 +25362,20 @@ function typeTag(value) {
   return "Object";
 }
 
+// packages/safe-js/src/interp/data-checkpoint.ts
+function createDataCheckpoint(budget, context) {
+  let estimatedDataSize = 0;
+  return (value, growth = 0, force = false) => {
+    const limit = budget.limits.dataSize;
+    if (limit === void 0) return;
+    estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
+    if (!force && estimatedDataSize <= limit) return;
+    if (context?.reconcileData !== void 0) context.reconcileData(value);
+    else reconcileCompiledValues(budget, [value], context?.compilation);
+    estimatedDataSize = budget.currentDataSize;
+  };
+}
+
 // packages/safe-js/src/interp/globals/collections.ts
 var mapConstructors = /* @__PURE__ */ new WeakSet();
 var setConstructors = /* @__PURE__ */ new WeakSet();
@@ -25371,12 +25385,27 @@ function createCollectionGlobals(options) {
     call: () => {
       throw new TypeError("Constructor Map requires 'new'.");
     },
-    construct: ([source]) => {
-      const entries = getMapEntries(source);
-      if (entries instanceof Promise) {
-        return entries.then((resolved) => createBudgetedMap(resolved, options.budget));
-      }
-      return createBudgetedMap(entries, options.budget);
+    construct: ([source], context) => {
+      const map = createSandboxMap([]);
+      let key;
+      let value;
+      return populateCollection(source, map, {
+        name: "Map",
+        budget: options.budget,
+        context,
+        retainedValues: () => [key, value],
+        append: (entry) => {
+          if (typeof entry !== "object" || entry === null) throw new TypeError("Map constructor requires entry objects.");
+          key = context?.getProperty !== void 0 ? context.getProperty(entry, 0) : getSandboxDataProperty(entry, 0, options.budget);
+          value = context?.getProperty !== void 0 ? context.getProperty(entry, 1) : getSandboxDataProperty(entry, 1, options.budget);
+          const added = map.entries.has(key) ? 0 : 1;
+          const growth = added + (options.budget.limits.dataSize === void 0 ? 0 : measureSandboxData([key, value]));
+          options.budget.allocateCollectionEntries(map.entries.size + added);
+          map.entries.set(key, value);
+          key = value = void 0;
+          return growth;
+        }
+      });
     },
     name: "Map"
   });
@@ -25385,12 +25414,20 @@ function createCollectionGlobals(options) {
     call: () => {
       throw new TypeError("Constructor Set requires 'new'.");
     },
-    construct: ([source]) => {
-      const values = getSetValues(source);
-      if (values instanceof Promise) {
-        return values.then((resolved) => createBudgetedSet(resolved, options.budget));
-      }
-      return createBudgetedSet(values, options.budget);
+    construct: ([source], context) => {
+      const set = createSandboxSet([]);
+      return populateCollection(source, set, {
+        name: "Set",
+        budget: options.budget,
+        context,
+        append: (value) => {
+          const added = set.values.has(value) ? 0 : 1;
+          const growth = added + (options.budget.limits.dataSize === void 0 ? 0 : measureSandboxData([value]));
+          options.budget.allocateCollectionEntries(set.values.size + added);
+          set.values.add(value);
+          return growth;
+        }
+      });
     },
     name: "Set"
   });
@@ -25404,71 +25441,68 @@ function isSandboxMapConstructor(value) {
 function isSandboxSetConstructor(value) {
   return typeof value === "object" && value !== null && setConstructors.has(value);
 }
-function getMapEntries(source) {
-  if (source === void 0 || source === null) {
-    return [];
-  }
-  if (isSandboxMap(source)) {
-    return [...source.entries];
-  }
-  if (Array.isArray(source)) {
-    return validateMapEntries(source);
-  }
+function populateCollection(source, collection, { name, budget, context, append, retainedValues }) {
+  budget.allocateCollectionEntries(0);
+  if (source === void 0 || source === null) return collection;
   const iterator = getSandboxIterator(source);
-  if (iterator?.generator !== true) {
-    throw new TypeError("Map constructor argument must be an array of pairs or a Map.");
-  }
-  return collectMapEntries(iterator);
-}
-async function collectMapEntries(iterator) {
-  const sourceEntries = [];
-  while (true) {
-    const result = await iterator.next();
-    if (result.done) break;
-    sourceEntries.push(result.value);
-  }
-  return validateMapEntries(sourceEntries);
-}
-function validateMapEntries(sourceEntries) {
-  return sourceEntries.map((entry) => {
-    if (!Array.isArray(entry)) {
-      throw new TypeError("Map constructor entries must be arrays.");
+  if (iterator === void 0) throw new TypeError(`${name} constructor requires an iterable.`);
+  let entry;
+  let failure;
+  const retained = {};
+  budget.setRetainedValues(retained, () => [source, collection, entry, failure, ...retainedValues?.() ?? []]);
+  const checkData = createDataCheckpoint(budget, context);
+  const closeOnThrow = (error) => {
+    failure = isCapturedException(error) ? error.reason : error;
+    const rethrow = (closeError) => {
+      if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
+      throw error;
+    };
+    try {
+      const closing = iterator.return?.();
+      if (iterator.generator) return Promise.resolve(closing).then(() => {
+        throw error;
+      }, rethrow);
+    } catch (closeError) {
+      return rethrow(closeError);
     }
-    return [entry[0], entry[1]];
-  });
-}
-function getSetValues(source) {
-  if (source === void 0 || source === null) {
-    return [];
-  }
-  if (isSandboxSet(source)) {
-    return [...source.values];
-  }
-  if (typeof source === "string") return [...source];
-  if (Array.isArray(source)) return [...source];
-  const iterator = getSandboxIterator(source);
-  if (iterator?.generator === true) {
-    return collectSetValues(iterator);
+    throw error;
+  };
+  const consume = (result) => {
+    if (typeof result !== "object" || result === null) throw new TypeError("Iterator result must be an object.");
+    if (result.done) return true;
+    entry = result.value;
+    try {
+      budget.visitNode();
+      const growth = append(entry);
+      entry = void 0;
+      checkData(collection, growth);
+    } catch (error) {
+      return closeOnThrow(error);
+    }
+    return false;
+  };
+  if (iterator.generator) {
+    return (async () => {
+      try {
+        checkData(collection, 0, true);
+        while (!await consume(await iterator.next())) {
+        }
+        checkData(collection, 0, true);
+        return collection;
+      } finally {
+        budget.setRetainedValues(retained, void 0);
+      }
+    })();
   }
-  throw new TypeError("Set constructor argument must be an array, string, or Set.");
-}
-async function collectSetValues(iterator) {
-  const values = [];
-  while (true) {
-    const result = await iterator.next();
-    if (result.done) break;
-    values.push(result.value);
+  try {
+    checkData(collection, 0, true);
+    while (!consume(iterator.next())) {
+    }
+    checkData(collection, 0, true);
+    return collection;
+  } finally {
+    budget.setRetainedValues(retained, void 0);
   }
-  return values;
-}
-function createBudgetedMap(entries, budget) {
-  const map = createSandboxMap(entries);
-  budget.allocateCollectionEntries(map.entries.size);
-  return map;
-}
-function createBudgetedSet(values, budget) {
-  budget.allocateCollectionEntries(new Set(values).size);
-  return createSandboxSet(values);
 }
 
 // packages/safe-js/src/interp/globals/float32array.ts
@@ -30836,18 +30870,6 @@ async function arrayFromSandboxValues(args, budget, context) {
     budget.setRetainedValues(retained, void 0);
   }
 }
-function createDataCheckpoint(budget, context) {
-  let estimatedDataSize = 0;
-  return (value, growth = 0, force = false) => {
-    const limit = budget.limits.dataSize;
-    if (limit === void 0) return;
-    estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
-    if (!force && estimatedDataSize <= limit) return;
-    if (context?.reconcileData !== void 0) context.reconcileData(value);
-    else reconcileCompiledValues(budget, [value], context?.compilation);
-    estimatedDataSize = budget.currentDataSize;
-  };
-}
 function createArrayFromConstructorArgs(args, budget) {
   if (args.length !== 1) {
     return budgetSandboxValue2(Reflect.apply(Array, Array, [...args]), budget);
@@ -33023,4 +33045,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-FV3SMFMZ.js.map
+//# sourceMappingURL=chunk-OCJ6MUNL.js.map