@poe-platform/safe-js 0.1.400 → 0.1.402

package/dist/safe-js/chunks/{chunk-ETP3MEHS.js → chunk-3DXEWN6Z.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-L5I53V56.js";
+} from "./chunk-5RNME7ZM.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-ETP3MEHS.js.map
+//# sourceMappingURL=chunk-3DXEWN6Z.js.map

package/dist/safe-js/chunks/{chunk-L5I53V56.js → chunk-5RNME7ZM.js}

@@ -8812,17 +8812,34 @@ async function flushPromiseJobs() {
 var promiseStates = /* @__PURE__ */ new WeakMap();
 
 // packages/safe-js/src/interp/promise-continuations.ts
+var promiseAggregateHandlers = /* @__PURE__ */ new WeakMap();
+var promiseAggregateStates = /* @__PURE__ */ new WeakMap();
+var promiseAggregateEntries = /* @__PURE__ */ new WeakMap();
 var promiseAdoptions = /* @__PURE__ */ new WeakMap();
 var promiseAdoptionBridges = /* @__PURE__ */ new WeakMap();
 var promiseAdoptionResolvers = /* @__PURE__ */ new WeakMap();
 var promiseContinuations = /* @__PURE__ */ new WeakMap();
 var promiseReactionResults = /* @__PURE__ */ new WeakMap();
+var promiseProducers = /* @__PURE__ */ new WeakMap();
+function linkPromiseAggregateProducer(producer, aggregate) {
+  const continuation = promiseContinuations.get(producer);
+  if (continuation?.kind !== "reaction") return;
+  continuation.aggregate = aggregate;
+  let producers = promiseProducers.get(aggregate);
+  if (producers === void 0) promiseProducers.set(aggregate, producers = /* @__PURE__ */ new Set());
+  producers.add(producer);
+}
 function trackPromiseContinuation(promise, continuation) {
   promiseContinuations.set(promise, continuation);
   if (continuation.kind === "reaction") {
     let results = promiseReactionResults.get(continuation.source);
     if (results === void 0) promiseReactionResults.set(continuation.source, results = /* @__PURE__ */ new Set());
     results.add(promise);
+    if (continuation.capability !== void 0) {
+      let producers = promiseProducers.get(continuation.capability.promise);
+      if (producers === void 0) promiseProducers.set(continuation.capability.promise, producers = /* @__PURE__ */ new Set());
+      producers.add(promise);
+    }
   }
   const release = () => {
     promiseContinuations.delete(promise);
@@ -8831,6 +8848,16 @@ function trackPromiseContinuation(promise, continuation) {
       const results = promiseReactionResults.get(continuation.source);
       results?.delete(promise);
       if (results?.size === 0) promiseReactionResults.delete(continuation.source);
+      if (continuation.capability !== void 0) {
+        const producers = promiseProducers.get(continuation.capability.promise);
+        producers?.delete(promise);
+        if (producers?.size === 0) promiseProducers.delete(continuation.capability.promise);
+      }
+      if (continuation.aggregate !== void 0) {
+        const producers = promiseProducers.get(continuation.aggregate);
+        producers?.delete(promise);
+        if (producers?.size === 0) promiseProducers.delete(continuation.aggregate);
+      }
     }
   };
   promise.promise.then(release, release);
@@ -21549,18 +21576,28 @@ function getPromisePrototype(budget) {
         const finish = (constructor2) => {
           if (!isSandboxPromiseConstructor(constructor2)) {
             return createPromiseCapability(constructor2, budget, context).then((capability) => {
-              if (isSandboxPromise(capability.promise)) unrepresentedPromiseContinuations.add(capability.promise);
-              observeSandboxPromise(target);
-              createSandboxPromise(target.promise.then(
+              observeSandboxPromise(target, isSandboxPromise(capability.promise));
+              const continuation2 = isSandboxPromise(capability.promise) ? {
+                kind: "reaction",
+                phase: "waiting",
+                source: target,
+                onFulfilled,
+                onRejected,
+                capability: { ...capability, promise: capability.promise }
+              } : void 0;
+              const completion = createSandboxPromise(target.promise.then(
                 (value) => {
+                  if (continuation2 !== void 0) continuation2.phase = "running";
                   consumeSettledHostCall(target);
                   return runCapabilityReaction(onFulfilled, value, "fulfilled", capability, budget, context);
                 },
                 (reason) => {
+                  if (continuation2 !== void 0) continuation2.phase = "running";
                   consumeSettledHostCall(target);
                   return runCapabilityReaction(onRejected, reason, "rejected", capability, budget, context);
                 }
               ));
+              if (continuation2 !== void 0) trackPromiseContinuation(completion, continuation2);
               return capability.promise;
             });
           }
@@ -21736,34 +21773,9 @@ async function settleIterable(iterable, method, budget, constructor, context) {
   const prototype = getPromisePrototype(budget);
   if (isSandboxPromise(capability.promise)) unrepresentedPromiseContinuations.add(capability.promise);
   const values = [];
-  let remaining = 1;
-  const complete2 = async () => {
-    if (remaining !== 0 || method === "race") return;
-    if (method === "any") {
-      const error = createSubsetErrorValue(
-        "AggregateError",
-        "All promises were rejected",
-        [],
-        budget
-      );
-      error.errors = values;
-      await callPromiseClosure(
-        capability.reject,
-        [budgetSandboxValue2(error, budget)],
-        void 0,
-        budget,
-        context
-      );
-    } else {
-      await callPromiseClosure(
-        capability.resolve,
-        [budgetSandboxValue2(values, budget)],
-        void 0,
-        budget,
-        context
-      );
-    }
-  };
+  const aggregate = { method, capability, values, remaining: 1, size: 0, iteration: "active" };
+  promiseAggregateStates.set(aggregate, aggregate);
+  let represented = true;
   try {
     const promiseResolve = await readPromiseReceiverProperty(constructor, "resolve", prototype, context);
     if (!isSandboxClosure(promiseResolve))
@@ -21772,7 +21784,6 @@ async function settleIterable(iterable, method, budget, constructor, context) {
     if (iterator === void 0) throw new TypeError("Promise helpers require an iterable.");
     const releaseIterator = retainValues(budget, () => [iterator.retainedValue]);
     try {
-      let index = 0;
       while (true) {
         budget.visitNode();
         const next = iterator.generator || iterator.asynchronous ? await iterator.next() : iterator.next();
@@ -21781,8 +21792,8 @@ async function settleIterable(iterable, method, budget, constructor, context) {
         if ((await readIteratorResult(iterator, next, "done")).value) break;
         const value = (await readIteratorResult(iterator, next, "value")).value;
         try {
-          budget.allocateArrayLength(index + 1);
-          const entryIndex = index++;
+          budget.allocateArrayLength(aggregate.size + 1);
+          const entryIndex = aggregate.size++;
           if (method !== "race") values.push(void 0);
           const entry = await callPromiseClosure(
             promiseResolve,
@@ -21791,45 +21802,41 @@ async function settleIterable(iterable, method, budget, constructor, context) {
             budget,
             context
           );
-          let called = false;
+          const aggregateEntry = { aggregate, index: entryIndex, called: false };
           const handlers = ["fulfilled", "rejected"].map((state) => {
             if (method === "race" || method === "any" && state === "fulfilled")
               return state === "fulfilled" ? capability.resolve : capability.reject;
             if (method === "all" && state === "rejected") return capability.reject;
-            return createSandboxClosure({
-              sandbox: true,
-              retainedValues: () => [
-                capability.promise,
-                capability.resolve,
-                capability.reject,
-                values
-              ],
-              call: async ([settlement]) => {
-                if (called) return void 0;
-                called = true;
-                values[entryIndex] = method === "allSettled" ? state === "fulfilled" ? { status: state, value: settlement } : { status: state, reason: settlement } : settlement;
-                remaining--;
-                await complete2();
-                return void 0;
-              }
-            });
+            return createPromiseAggregateHandler(aggregateEntry, state, budget, context);
           });
-          remaining++;
+          aggregate.remaining++;
           const then = await readPromiseProperty(entry, "then", prototype, budget, context);
           if (!isSandboxClosure(then))
             throw new TypeError("Promise resolver result requires a callable then.");
-          await callPromiseClosure(then, handlers, entry, budget, context);
+          const previousReactions = isSandboxPromise(entry) ? new Set(promiseReactionResults.get(entry)) : void 0;
+          const completion = await callPromiseClosure(then, handlers, entry, budget, context);
+          if (!intrinsicPromiseThenMethods.has(then) || !isSandboxPromise(entry) || !isSandboxPromise(completion)) represented = false;
+          else if (isSandboxPromise(capability.promise)) {
+            for (const producer of promiseReactionResults.get(entry) ?? []) {
+              const reaction = promiseContinuations.get(producer);
+              if (!previousReactions?.has(producer) && reaction?.kind === "reaction" && reaction.onFulfilled === handlers[0] && reaction.onRejected === handlers[1])
+                linkPromiseAggregateProducer(producer, capability.promise);
+            }
+          }
         } catch (error) {
           await closeIterator(iterator, true);
           throw error;
         }
       }
-      remaining--;
-      await complete2();
+      aggregate.remaining--;
+      aggregate.iteration = "complete";
+      await completePromiseAggregate(aggregate, budget, context);
+      if (represented && isSandboxPromise(capability.promise)) unrepresentedPromiseContinuations.delete(capability.promise);
     } finally {
       releaseIterator();
     }
   } catch (error) {
+    aggregate.iteration = "abrupt";
     if (error instanceof SandboxError && (error.code === "budgetExceeded" || error.code === "reentry")) {
       if (isSandboxPromise(capability.promise)) observeSandboxPromise(capability.promise);
       throw error;
@@ -21844,6 +21851,39 @@ async function settleIterable(iterable, method, budget, constructor, context) {
   }
   return capability.promise;
 }
+async function completePromiseAggregate(aggregate, budget, context) {
+  const { method, capability, values, remaining } = aggregate;
+  if (remaining !== 0 || method === "race") return;
+  if (method === "any") {
+    const error = createSubsetErrorValue("AggregateError", "All promises were rejected", [], budget);
+    error.errors = values;
+    await callPromiseClosure(capability.reject, [budgetSandboxValue2(error, budget)], void 0, budget, context);
+  } else {
+    await callPromiseClosure(capability.resolve, [budgetSandboxValue2(values, budget)], void 0, budget, context);
+  }
+}
+function createPromiseAggregateHandler(entry, action, budget, context) {
+  const { aggregate } = entry;
+  promiseAggregateEntries.set(entry, entry);
+  const handler = createSandboxClosure({
+    sandbox: true,
+    guest: true,
+    name: "",
+    length: 1,
+    retainedValues: () => [aggregate.capability.promise, aggregate.capability.resolve, aggregate.capability.reject, aggregate.values],
+    call: async ([settlement]) => {
+      if (entry.called) return void 0;
+      entry.called = true;
+      const { method, values } = aggregate;
+      values[entry.index] = method === "allSettled" ? action === "fulfilled" ? { status: action, value: settlement } : { status: action, reason: settlement } : settlement;
+      aggregate.remaining--;
+      await completePromiseAggregate(aggregate, budget, context);
+      return void 0;
+    }
+  });
+  promiseAggregateHandlers.set(handler, { entry, action });
+  return handler;
+}
 function schedulePromise(promise, budget) {
   return Promise.resolve().then(
     () => promise.then(
@@ -22319,6 +22359,29 @@ function serializeCollectionProperties(value, encode, dataOnly = false) {
 
 // packages/safe-js/src/snapshot/guest-heap.ts
 function captureGuestHeapNode(value, encode) {
+  const aggregate = promiseAggregateStates.get(value);
+  if (aggregate !== void 0) {
+    if (aggregate.iteration === "active") throw new TypeError("Cannot snapshot an active promise aggregate iterator.");
+    return {
+      kind: "promise-aggregate",
+      method: aggregate.method,
+      remaining: aggregate.remaining,
+      size: aggregate.size,
+      iteration: aggregate.iteration,
+      values: encode(aggregate.values),
+      capability: {
+        promise: encode(aggregate.capability.promise),
+        resolve: encode(aggregate.capability.resolve),
+        reject: encode(aggregate.capability.reject)
+      }
+    };
+  }
+  const aggregateEntry = promiseAggregateEntries.get(value);
+  if (aggregateEntry !== void 0)
+    return { kind: "aggregate-entry", aggregate: encode(aggregateEntry.aggregate), index: aggregateEntry.index, called: aggregateEntry.called };
+  const aggregateHandler = isSandboxClosure(value) ? promiseAggregateHandlers.get(value) : void 0;
+  if (aggregateHandler !== void 0)
+    return { kind: "aggregate-handler", entry: encode(aggregateHandler.entry), action: aggregateHandler.action, state: captureObjectState(value, encode) };
   const bridge = promiseAdoptionBridges.get(value);
   if (bridge !== void 0) {
     if (bridge.settled || bridge.owner === void 0) return void 0;
@@ -22339,12 +22402,14 @@ function captureGuestHeapNode(value, encode) {
     return { kind: "promise-resolver", promise: encode(resolver.promise), state: captureObjectState(value, encode) };
   }
   if (isSandboxPromise(value)) {
+    const producerState = promiseProducers.has(value) ? { producers: [...promiseProducers.get(value)].map(encode) } : {};
     const settlement = promiseStates.get(value);
     if (settlement !== void 0 && settlement.status !== "pending")
       return {
         kind: "guest-promise",
         status: settlement.status,
         value: encode(settlement.value),
+        ...producerState,
         ...promiseReactionResults.has(value) ? { reactions: [...promiseReactionResults.get(value)].map(encode) } : {},
         state: captureObjectState(value, encode)
       };
@@ -22358,6 +22423,7 @@ function captureGuestHeapNode(value, encode) {
       return {
         kind: "pending-promise",
         ...continuation.state.settled ? { adoption: encode(adoption) } : {},
+        ...producerState,
         reactions: [...promiseReactionResults.get(value) ?? []].map(encode),
         state: captureObjectState(value, encode)
       };
@@ -22366,6 +22432,13 @@ function captureGuestHeapNode(value, encode) {
       return {
         kind: "promise-reaction",
         source: encode(continuation.source),
+        ...producerState,
+        ...continuation.aggregate === void 0 ? {} : { aggregate: encode(continuation.aggregate) },
+        ...continuation.capability === void 0 ? {} : { capability: {
+          promise: encode(continuation.capability.promise),
+          resolve: encode(continuation.capability.resolve),
+          reject: encode(continuation.capability.reject)
+        } },
         onFulfilled: encode(continuation.onFulfilled),
         onRejected: encode(continuation.onRejected),
         reactions: [...promiseReactionResults.get(value) ?? []].map(encode),
@@ -27828,7 +27901,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
+  if (!["promise-aggregate", "aggregate-entry", "aggregate-handler", "intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record3(value);
     fields(ref, ["kind", "id"]);
@@ -27900,6 +27973,17 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       if (typeof descriptor.enumerable !== "boolean" || typeof descriptor.configurable !== "boolean") throw new TypeError("Invalid guest descriptor flags.");
     }
   };
+  if (Object.hasOwn(node, "producers")) {
+    const producers = /* @__PURE__ */ new Set();
+    for (const entry of array(node.producers)) {
+      const producer = reference(entry, ["promise-reaction"]);
+      const capabilityOwner = producer.capability === void 0 ? void 0 : reference(record3(producer.capability).promise);
+      const aggregateOwner = producer.aggregate === void 0 ? void 0 : reference(producer.aggregate);
+      if (producers.has(producer) || capabilityOwner !== node && aggregateOwner !== node)
+        throw new TypeError("Invalid promise producer ownership.");
+      producers.add(producer);
+    }
+  }
   if (node.kind === "map" || node.kind === "set") {
     fields(node, ["kind", node.kind === "map" ? "entries" : "values"], ["propertyState", "prototype", "privateElements"]);
     if (node.privateElements !== void 0) privateState(node.privateElements);
@@ -27909,7 +27993,30 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     });
     return false;
   }
-  if (node.kind === "promise-adoption") {
+  if (node.kind === "promise-aggregate") {
+    fields(node, ["kind", "method", "capability", "values", "remaining", "size", "iteration"]);
+    if (!["all", "allSettled", "race", "any"].includes(String(node.method))) throw new TypeError("Invalid promise aggregate method.");
+    const size = integer(node.size);
+    if (size > maxArrayLength || node.iteration !== "complete" && node.iteration !== "abrupt") throw new TypeError("Invalid promise aggregate iteration.");
+    if (integer(node.remaining) > size + (node.iteration === "abrupt" ? 1 : 0)) throw new TypeError("Invalid promise aggregate remaining count.");
+    reference(node.values, ["array", "guest-array"]);
+    const capability = record3(node.capability);
+    fields(capability, ["promise", "resolve", "reject"]);
+    if (absent(capability.resolve) || absent(capability.reject)) throw new TypeError("Missing promise aggregate resolver.");
+    callable(capability.resolve);
+    callable(capability.reject);
+  } else if (node.kind === "aggregate-entry") {
+    fields(node, ["kind", "aggregate", "index", "called"]);
+    const aggregate = reference(node.aggregate, ["promise-aggregate"]);
+    if (integer(node.index) >= integer(aggregate.size) || typeof node.called !== "boolean") throw new TypeError("Invalid promise aggregate entry.");
+  } else if (node.kind === "aggregate-handler") {
+    fields(node, ["kind", "entry", "action", "state"]);
+    state(node.state);
+    const entry = reference(node.entry, ["aggregate-entry"]);
+    const aggregate = reference(entry.aggregate, ["promise-aggregate"]);
+    if (node.action !== "fulfilled" && node.action !== "rejected" || aggregate.method === "all" && node.action !== "fulfilled" || aggregate.method === "any" && node.action !== "rejected" || aggregate.method === "race")
+      throw new TypeError("Invalid promise aggregate handler action.");
+  } else if (node.kind === "promise-adoption") {
     fields(node, ["kind", "owner", "source"]);
     const owner = reference(node.owner, ["pending-promise"]);
     if (reference(owner.adoption, ["promise-adoption"]) !== node) throw new TypeError("Invalid promise adoption owner.");
@@ -27941,12 +28048,40 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       throw new TypeError("Invalid promise resolver action.");
     state(node.state);
   } else if (node.kind === "pending-promise" || node.kind === "promise-reaction") {
-    fields(node, node.kind === "pending-promise" ? ["kind", "reactions", "state"] : ["kind", "source", "onFulfilled", "onRejected", "reactions", "state"], node.kind === "pending-promise" ? ["adoption"] : []);
+    fields(node, node.kind === "pending-promise" ? ["kind", "reactions", "state"] : ["kind", "source", "onFulfilled", "onRejected", "reactions", "state"], node.kind === "pending-promise" ? ["adoption", "producers"] : ["capability", "aggregate", "producers"]);
     if (node.kind === "pending-promise" && Object.hasOwn(node, "adoption")) {
       const bridge = reference(node.adoption, ["promise-adoption"]);
       if (reference(bridge.owner, ["pending-promise"]) !== node) throw new TypeError("Invalid promise adoption owner.");
     }
     if (node.kind === "promise-reaction") {
+      if (Object.hasOwn(node, "aggregate")) {
+        const aggregate = reference(node.aggregate, ["pending-promise", "guest-promise", "promise-reaction"]);
+        if (aggregate === node || !Array.isArray(aggregate.producers) || !aggregate.producers.some((entry) => reference(entry, ["promise-reaction"]) === node))
+          throw new TypeError("Invalid promise aggregate producer ownership.");
+        for (const value of [node.onFulfilled, node.onRejected]) {
+          if (absent(value)) continue;
+          const handler = reference(value);
+          let owner;
+          if (handler.kind === "promise-resolver") owner = reference(handler.promise);
+          else if (handler.kind === "aggregate-handler") {
+            const entry = reference(handler.entry, ["aggregate-entry"]);
+            const state2 = reference(entry.aggregate, ["promise-aggregate"]);
+            owner = reference(record3(state2.capability).promise);
+          }
+          if (owner !== void 0 && owner !== aggregate) throw new TypeError("Invalid promise aggregate handler ownership.");
+        }
+      }
+      if (Object.hasOwn(node, "capability")) {
+        const capability = record3(node.capability);
+        fields(capability, ["promise", "resolve", "reject"]);
+        const result = reference(capability.promise, ["pending-promise", "guest-promise", "promise-reaction"]);
+        if (result === node) throw new TypeError("Invalid promise producer ownership.");
+        if (!Array.isArray(result.producers) || !result.producers.some((entry) => reference(entry, ["promise-reaction"]) === node))
+          throw new TypeError("Unlisted promise producer.");
+        if (absent(capability.resolve) || absent(capability.reject)) throw new TypeError("Missing promise producer resolver.");
+        callable(capability.resolve);
+        callable(capability.reject);
+      }
       const source = reference(node.source, ["pending-promise", "promise-reaction", "guest-promise"]);
       if (!Array.isArray(source.reactions) || !source.reactions.some((entry) => reference(entry, ["promise-reaction"]) === node))
         throw new TypeError("Unlisted promise reaction.");
@@ -27961,7 +28096,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     }
     state(node.state);
   } else if (node.kind === "guest-promise") {
-    fields(node, ["kind", "status", "value", "state"], ["reactions"]);
+    fields(node, ["kind", "status", "value", "state"], ["reactions", "producers"]);
     if (Object.hasOwn(node, "reactions")) {
       if (!Array.isArray(node.reactions)) throw new TypeError("Invalid promise reactions.");
       const reactions = /* @__PURE__ */ new Set();
@@ -30200,8 +30335,15 @@ function measureSandboxData(values, options = {}) {
         visit(continuation.source, depth + 1);
         visit(continuation.onFulfilled, depth + 1);
         visit(continuation.onRejected, depth + 1);
+        if (continuation.capability !== void 0) {
+          visit(continuation.capability.promise, depth + 1);
+          visit(continuation.capability.resolve, depth + 1);
+          visit(continuation.capability.reject, depth + 1);
+        }
+        if (continuation.aggregate !== void 0) visit(continuation.aggregate, depth + 1);
       }
       for (const reaction of promiseReactionResults.get(value) ?? []) visit(reaction, depth + 1);
+      for (const producer of promiseProducers.get(value) ?? []) visit(producer, depth + 1);
       for (const key of Reflect.ownKeys(getPromiseProperties(value))) {
         const descriptor = Object.getOwnPropertyDescriptor(getPromiseProperties(value), key);
         usage += typeof key === "string" ? key.length + 1 : 1;
@@ -45217,4 +45359,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-L5I53V56.js.map
+//# sourceMappingURL=chunk-5RNME7ZM.js.map