@poe-platform/safe-js 0.1.401 → 0.1.403

package/dist/safe-js/chunks/{chunk-YFCLIG72.js → chunk-5KXKPBGW.js}

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

package/dist/safe-js/chunks/{chunk-HDEGJ4AI.js → chunk-DXLKDLGM.js}

@@ -8812,12 +8812,24 @@ async function flushPromiseJobs() {
 var promiseStates = /* @__PURE__ */ new WeakMap();
 
 // packages/safe-js/src/interp/promise-continuations.ts
+var promiseCapabilityExecutors = /* @__PURE__ */ new WeakMap();
+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") {
@@ -8842,6 +8854,11 @@ function trackPromiseContinuation(promise, continuation) {
         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);
@@ -21500,19 +21517,8 @@ async function createPromiseCapability(constructor, budget, context) {
   if (!isSandboxClosure(constructor) || constructor.construct === void 0) {
     throw new TypeError("Promise method requires a constructor receiver.");
   }
-  let resolve;
-  let reject;
-  const executor = createSandboxClosure({
-    sandbox: true,
-    retainedValues: () => [resolve, reject],
-    call: (args) => {
-      if (resolve !== void 0 || reject !== void 0) {
-        throw new TypeError("Promise capability is already initialized.");
-      }
-      [resolve, reject] = args;
-      return void 0;
-    }
-  });
+  const state = { resolve: void 0, reject: void 0 };
+  const executor = createPromiseCapabilityExecutor(state);
   const leaveCall = budget.enterCall();
   try {
     const promise = await constructor.construct([executor], {
@@ -21521,6 +21527,7 @@ async function createPromiseCapability(constructor, budget, context) {
       thisValue: void 0,
       newTarget: constructor
     });
+    const { resolve, reject } = state;
     if (!isSandboxClosure(resolve) || !isSandboxClosure(reject)) {
       throw new TypeError("Promise capability requires callable resolve and reject functions.");
     }
@@ -21529,6 +21536,24 @@ async function createPromiseCapability(constructor, budget, context) {
     leaveCall();
   }
 }
+function createPromiseCapabilityExecutor(state) {
+  const executor = createSandboxClosure({
+    sandbox: true,
+    guest: true,
+    name: "",
+    length: 2,
+    retainedValues: () => [state.resolve, state.reject],
+    call: ([resolve, reject]) => {
+      if (state.resolve !== void 0 || state.reject !== void 0)
+        throw new TypeError("Promise capability is already initialized.");
+      state.resolve = resolve;
+      state.reject = reject;
+      return void 0;
+    }
+  });
+  promiseCapabilityExecutors.set(executor, state);
+  return executor;
+}
 async function callPromiseClosure(callback, args, thisValue, budget, context) {
   const leaveCall = budget.enterCall();
   try {
@@ -21757,34 +21782,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))
@@ -21793,7 +21793,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();
@@ -21802,8 +21801,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,
@@ -21812,45 +21811,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;
@@ -21865,6 +21860,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(
@@ -22340,6 +22368,32 @@ function serializeCollectionProperties(value, encode, dataOnly = false) {
 
 // packages/safe-js/src/snapshot/guest-heap.ts
 function captureGuestHeapNode(value, encode) {
+  const executor = isSandboxClosure(value) ? promiseCapabilityExecutors.get(value) : void 0;
+  if (executor !== void 0)
+    return { kind: "capability-executor", resolve: encode(executor.resolve), reject: encode(executor.reject), state: captureObjectState(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;
@@ -22391,6 +22445,7 @@ function captureGuestHeapNode(value, encode) {
         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),
@@ -27858,7 +27913,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 (!["capability-executor", "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"]);
@@ -27869,7 +27924,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
   };
   const callable = (value) => {
     if (absent(value)) return;
-    const target = reference(value, ["intrinsic", "bound-function", "promise-resolver", "guest-function", "guest-class"]);
+    const target = reference(value, ["capability-executor", "intrinsic", "bound-function", "promise-resolver", "guest-function", "guest-class"]);
     if (target.kind === "intrinsic" && intrinsicCatalogue().get(String(target.id)) !== true)
       throw new TypeError("Guest accessor reference is not callable.");
   };
@@ -27934,7 +27989,9 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     const producers = /* @__PURE__ */ new Set();
     for (const entry of array(node.producers)) {
       const producer = reference(entry, ["promise-reaction"]);
-      if (producers.has(producer) || reference(record3(producer.capability).promise) !== node)
+      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);
     }
@@ -27948,7 +28005,33 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     });
     return false;
   }
-  if (node.kind === "promise-adoption") {
+  if (node.kind === "capability-executor") {
+    fields(node, ["kind", "resolve", "reject", "state"]);
+    state(node.state);
+  } else 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.");
@@ -27980,12 +28063,29 @@ 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", "producers"] : ["capability", "producers"]);
+    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"]);
@@ -30255,6 +30355,7 @@ function measureSandboxData(values, options = {}) {
           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);
@@ -45273,4 +45374,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-HDEGJ4AI.js.map
+//# sourceMappingURL=chunk-DXLKDLGM.js.map