@poe-platform/safe-js 0.1.397 → 0.1.399

package/dist/safe-js/chunks/{chunk-6HQSVAXP.js → chunk-L4AQGNFP.js}

@@ -8695,6 +8695,7 @@ import { types as nodeTypes } from "node:util";
 
 // packages/safe-js/src/interp/promise-tracker.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var unrepresentedPromiseContinuations = /* @__PURE__ */ new WeakSet();
 var SandboxPromiseRejectionTracker = class {
   records = /* @__PURE__ */ new Set();
   recordsByPromise = /* @__PURE__ */ new WeakMap();
@@ -8791,7 +8792,8 @@ function withFatalPromiseCleanup(callback) {
 function createSandboxPromiseRejectionTracker() {
   return new SandboxPromiseRejectionTracker();
 }
-function observeSandboxPromise(promise) {
+function observeSandboxPromise(promise, represented = false) {
+  if (!represented) unrepresentedPromiseContinuations.add(promise);
   activePromiseTracker.getStore()?.observe(promise);
 }
 function trackSandboxPromise(promise, outcome) {
@@ -8809,6 +8811,31 @@ async function flushPromiseJobs() {
 // packages/safe-js/src/interp/promise-state.ts
 var promiseStates = /* @__PURE__ */ new WeakMap();
 
+// packages/safe-js/src/interp/promise-continuations.ts
+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();
+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);
+  }
+  const release = () => {
+    promiseContinuations.delete(promise);
+    if (continuation.kind === "capability") delete continuation.resolution;
+    else {
+      const results = promiseReactionResults.get(continuation.source);
+      results?.delete(promise);
+      if (results?.size === 0) promiseReactionResults.delete(continuation.source);
+    }
+  };
+  promise.promise.then(release, release);
+}
+
 // packages/safe-js/src/interp/promise-replay.ts
 import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
 
@@ -9409,6 +9436,9 @@ var SandboxJobQueue = class {
   ready = [];
   idle = [];
   generation = 0;
+  bind(task) {
+    return activeJob.run({ queue: this, ownsExecution: false }, task);
+  }
   acquire(job) {
     return new Promise((resolve) => {
       this.pending.push(() => {
@@ -21187,6 +21217,7 @@ async function copyObjectRest(value, excludedKeys, context) {
 
 // packages/safe-js/src/interp/promise-resolvers.ts
 var promiseResolvingFunctions = /* @__PURE__ */ new WeakMap();
+var promiseResolverActions = /* @__PURE__ */ new WeakMap();
 
 // packages/safe-js/src/interp/promise.ts
 var promiseConstructors = /* @__PURE__ */ new WeakSet();
@@ -21199,6 +21230,44 @@ function isSandboxPromiseConstructor(value) {
 function isPromiseResolvingFunction(value) {
   return isSandboxClosure(value) && promiseResolvingFunctions.has(value);
 }
+function createPendingPromiseCapability(budget, context) {
+  let fulfill;
+  let reject;
+  const promise = createSandboxPromise(new Promise((resolve, rejectPromise) => {
+    fulfill = resolve;
+    reject = rejectPromise;
+  }), { span: context?.span });
+  const resolverState = { promise, settled: false };
+  const continuation = { kind: "capability", state: resolverState };
+  trackPromiseContinuation(promise, continuation);
+  const resolvers = ["fulfilled", "rejected"].map((status) => {
+    const resolver = createSandboxClosure({
+      sandbox: true,
+      guest: true,
+      name: "",
+      length: 1,
+      retainedValues: () => [promise],
+      call: ([value]) => {
+        if (resolverState.settled) return void 0;
+        resolverState.settled = true;
+        continuation.resolution = { status, value };
+        try {
+          if (status === "rejected") reject(budgetSandboxValue2(value, budget));
+          else if (value === promise)
+            reject(createSubsetErrorValue("TypeError", "Promise cannot resolve to itself.", context?.stack ?? [], budget));
+          else fulfill(resolveSandboxValue(value, { budget, self: promise, context }));
+        } catch (error) {
+          reject(error);
+        }
+        return void 0;
+      }
+    });
+    promiseResolvingFunctions.set(resolver, resolverState);
+    promiseResolverActions.set(resolver, status);
+    return resolver;
+  });
+  return { promise, resolve: resolvers[0], reject: resolvers[1], fulfill, rejectNative: reject };
+}
 function createPromiseGlobals(options) {
   promisePrototypes2.delete(options.budget);
   const prototype = getPromisePrototype(options.budget);
@@ -21206,56 +21275,12 @@ function createPromiseGlobals(options) {
     if (!isSandboxClosure(executor)) throw new TypeError("Promise executor must be a function.");
     const prototypeValue = context?.newTarget === void 0 ? prototype : context.getProperty === void 0 ? getSandboxDataProperty(context.newTarget, "prototype", options.budget) : context.getProperty(context.newTarget, "prototype");
     const targetPrototype = prototypeValue instanceof Promise ? await prototypeValue : prototypeValue;
-    let fulfill;
-    let reject;
-    const pending = createSandboxPromise(
-      new Promise((resolve, rejectPromise) => {
-        fulfill = resolve;
-        reject = rejectPromise;
-      }),
-      { span: context?.span }
-    );
+    const capability = createPendingPromiseCapability(options.budget, context);
+    const pending = capability.promise;
     if (typeof targetPrototype === "object" && targetPrototype !== null && targetPrototype !== prototype)
       setSandboxPrototype(pending, targetPrototype, options.budget);
-    const resolverState = { promise: pending, settled: false };
-    const settle = (state, value) => {
-      if (resolverState.settled) return;
-      resolverState.settled = true;
-      try {
-        if (state === "rejected") {
-          reject(budgetSandboxValue2(value, options.budget));
-        } else if (value === pending) {
-          reject(
-            createSubsetErrorValue(
-              "TypeError",
-              "Promise cannot resolve to itself.",
-              context?.stack ?? [],
-              options.budget
-            )
-          );
-        } else {
-          fulfill(resolveSandboxValue(value, { budget: options.budget, self: pending, context }));
-        }
-      } catch (error) {
-        reject(error);
-      }
-    };
     try {
-      const resolvers = ["fulfilled", "rejected"].map((state) => {
-        const resolver = createSandboxClosure({
-          sandbox: true,
-          guest: true,
-          name: "",
-          length: 1,
-          retainedValues: () => [pending],
-          call: ([value]) => {
-            settle(state, value);
-            return void 0;
-          }
-        });
-        promiseResolvingFunctions.set(resolver, resolverState);
-        return resolver;
-      });
+      const resolvers = [capability.resolve, capability.reject];
       const result = executor.call(resolvers, { stack: context?.stack ?? [], thisValue: void 0 });
       if (executor.async !== true) await result;
       else if (isSandboxPromise(result) && result.synchronousPrefix !== void 0)
@@ -21266,7 +21291,7 @@ function createPromiseGlobals(options) {
         observeSandboxPromise(pending);
         throw error;
       }
-      settle("rejected", error);
+      capability.reject.call([error]);
     }
     return pending;
   };
@@ -21524,6 +21549,7 @@ 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(
                 (value) => {
@@ -21538,19 +21564,29 @@ function getPromisePrototype(budget) {
               return capability.promise;
             });
           }
-          observeSandboxPromise(target);
+          observeSandboxPromise(target, true);
+          const continuation = {
+            kind: "reaction",
+            phase: "waiting",
+            source: target,
+            onFulfilled,
+            onRejected
+          };
           const chained = createSandboxPromise(
             target.promise.then(
               (value) => {
+                continuation.phase = "running";
                 consumeSettledHostCall(target);
                 return runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained, context);
               },
               (reason) => {
+                continuation.phase = "running";
                 consumeSettledHostCall(target);
                 return runPromiseReaction(onRejected, reason, "rejected", budget, chained, context);
               }
             )
           );
+          trackPromiseContinuation(chained, continuation);
           return chained;
         };
         const constructor = getPromiseSpeciesConstructor(target, prototype, budget, context);
@@ -21698,6 +21734,7 @@ function readPromiseProperty(receiver, property, prototype, budget, context) {
 async function settleIterable(iterable, method, budget, constructor, context) {
   const capability = await createPromiseCapability(constructor, budget, context);
   const prototype = getPromisePrototype(budget);
+  if (isSandboxPromise(capability.promise)) unrepresentedPromiseContinuations.add(capability.promise);
   const values = [];
   let remaining = 1;
   const complete2 = async () => {
@@ -22031,6 +22068,57 @@ function callInPromiseJob(handler, args, thisValue = void 0, completion, context
     }
   });
 }
+function createPromiseAdoptionBridge(source, budget, owner, context) {
+  let fulfill;
+  let rejectNative;
+  const promise = new Promise((resolve, reject) => {
+    fulfill = resolve;
+    rejectNative = reject;
+  });
+  const token = /* @__PURE__ */ Object.create(null);
+  const settle = (status, value) => {
+    if (bridge.settled) return;
+    bridge.settled = true;
+    try {
+      if (status === "rejected") rejectNative(budgetSandboxValue2(value, budget));
+      else if (requiresPromiseResolution(value, budget)) {
+        fulfill(resolvePromiseResult(value, budget, owner, context));
+      } else fulfill(budgetSandboxValue2(value, budget));
+    } catch (error) {
+      rejectNative(error);
+    }
+  };
+  const resolvers = ["fulfilled", "rejected"].map((action) => {
+    const resolver = createSandboxClosure({
+      sandbox: true,
+      retainedValues: () => [source, owner],
+      call: ([value]) => {
+        settle(action, value);
+        return void 0;
+      }
+    });
+    promiseAdoptionResolvers.set(resolver, { bridge: token, action });
+    return resolver;
+  });
+  const bridge = {
+    source,
+    owner,
+    settled: false,
+    promise,
+    resolve: resolvers[0],
+    reject: resolvers[1],
+    rejectNative
+  };
+  promiseAdoptionBridges.set(token, bridge);
+  if (owner !== void 0) promiseAdoptions.set(owner, token);
+  const release = () => {
+    if (owner !== void 0 && promiseAdoptions.get(owner) === token) promiseAdoptions.delete(owner);
+    promiseAdoptionBridges.delete(token);
+    for (const resolver of resolvers) promiseAdoptionResolvers.delete(resolver);
+  };
+  promise.then(release, release);
+  return { token, bridge };
+}
 function resolvePromiseResult(result, budget, self, context) {
   if (isPromiseLike2(result)) {
     return Promise.resolve(result).then((resolved) => resolvePromiseResult(resolved, budget, self, context));
@@ -22045,58 +22133,28 @@ function resolvePromiseResult(result, budget, self, context) {
   }
   const then = getSandboxPropertyDescriptor(result, "then", budget)?.value ?? getPromiseMember("then", budget);
   if (!isSandboxClosure(then)) return Promise.resolve(result);
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const settle = (state, value) => {
-      if (settled) return;
-      settled = true;
-      try {
-        if (state === "rejected") reject(budgetSandboxValue2(value, budget));
-        else if (requiresPromiseResolution(value, budget)) {
-          resolve(resolvePromiseResult(value, budget, self, context));
-        } else {
-          resolve(budgetSandboxValue2(value, budget));
-        }
-      } catch (error) {
-        reject(error);
-      }
-    };
-    runPromiseJob(async () => {
-      try {
-        const completion = await callPromiseClosure(
-          then,
-          [
-            createSandboxClosure({
-              sandbox: true,
-              call: ([value]) => {
-                settle("fulfilled", value);
-                return void 0;
-              }
-            }),
-            createSandboxClosure({
-              sandbox: true,
-              call: ([reason]) => {
-                settle("rejected", reason);
-                return void 0;
-              }
-            })
-          ],
-          result,
-          budget,
-          context
-        );
-        if (isSandboxPromise(completion)) {
-          completion.promise.catch((reason) => {
-            if (reason instanceof SandboxError && (reason.code === "budgetExceeded" || reason.code === "reentry")) {
-              reject(reason);
-            }
-          });
-        }
-      } catch (error) {
-        settle("rejected", error);
+  const { bridge } = createPromiseAdoptionBridge(result, budget, self, context);
+  runPromiseJob(async () => {
+    try {
+      const completion = await callPromiseClosure(
+        then,
+        [bridge.resolve, bridge.reject],
+        result,
+        budget,
+        context
+      );
+      if (isSandboxPromise(completion)) {
+        completion.promise.catch((reason) => {
+          if (reason instanceof SandboxError && (reason.code === "budgetExceeded" || reason.code === "reentry")) {
+            bridge.rejectNative(reason);
+          }
+        });
       }
-    }).catch(reject);
-  });
+    } catch (error) {
+      bridge.reject.call([error]);
+    }
+  }).catch(bridge.rejectNative);
+  return bridge.promise;
 }
 function isSelfResolution(result, self) {
   return self !== void 0 && (result === self || isSandboxPromise(result) && result.promise === self.promise);
@@ -22261,16 +22319,58 @@ function serializeCollectionProperties(value, encode, dataOnly = false) {
 
 // packages/safe-js/src/snapshot/guest-heap.ts
 function captureGuestHeapNode(value, encode) {
+  const bridge = promiseAdoptionBridges.get(value);
+  if (bridge !== void 0) {
+    if (bridge.settled || bridge.owner === void 0) return void 0;
+    return { kind: "promise-adoption", owner: encode(bridge.owner), source: encode(bridge.source) };
+  }
+  const adoptionResolver = isSandboxClosure(value) ? promiseAdoptionResolvers.get(value) : void 0;
+  if (adoptionResolver !== void 0)
+    return { kind: "adoption-resolver", bridge: encode(adoptionResolver.bridge), action: adoptionResolver.action };
   const resolver = isSandboxClosure(value) ? promiseResolvingFunctions.get(value) : void 0;
   if (resolver !== void 0) {
     const settlement = promiseStates.get(resolver.promise);
-    if (!resolver.settled || settlement === void 0 || settlement.status === "pending") return void 0;
+    if (settlement?.status === "pending") {
+      const action = isSandboxClosure(value) ? promiseResolverActions.get(value) : void 0;
+      if (action === void 0) return void 0;
+      return { kind: "promise-resolver", promise: encode(resolver.promise), action, state: captureObjectState(value, encode) };
+    }
+    if (!resolver.settled || settlement === void 0) return void 0;
     return { kind: "promise-resolver", promise: encode(resolver.promise), state: captureObjectState(value, encode) };
   }
   if (isSandboxPromise(value)) {
     const settlement = promiseStates.get(value);
     if (settlement !== void 0 && settlement.status !== "pending")
-      return { kind: "guest-promise", status: settlement.status, value: encode(settlement.value), state: captureObjectState(value, encode) };
+      return {
+        kind: "guest-promise",
+        status: settlement.status,
+        value: encode(settlement.value),
+        ...promiseReactionResults.has(value) ? { reactions: [...promiseReactionResults.get(value)].map(encode) } : {},
+        state: captureObjectState(value, encode)
+      };
+    const continuation = promiseContinuations.get(value);
+    if (unrepresentedPromiseContinuations.has(value))
+      throw new TypeError("Cannot serialize host reference: unrepresented promise continuation.");
+    if (continuation?.kind === "capability") {
+      const adoption = promiseAdoptions.get(value);
+      const bridge2 = adoption === void 0 ? void 0 : promiseAdoptionBridges.get(adoption);
+      if (continuation.state.settled && (bridge2 === void 0 || bridge2.settled || bridge2.owner !== value || continuation.resolution?.status !== "fulfilled" || continuation.resolution.value !== bridge2.source)) return void 0;
+      return {
+        kind: "pending-promise",
+        ...continuation.state.settled ? { adoption: encode(adoption) } : {},
+        reactions: [...promiseReactionResults.get(value) ?? []].map(encode),
+        state: captureObjectState(value, encode)
+      };
+    }
+    if (continuation?.kind === "reaction" && continuation.phase === "waiting")
+      return {
+        kind: "promise-reaction",
+        source: encode(continuation.source),
+        onFulfilled: encode(continuation.onFulfilled),
+        onRejected: encode(continuation.onRejected),
+        reactions: [...promiseReactionResults.get(value) ?? []].map(encode),
+        state: captureObjectState(value, encode)
+      };
     return void 0;
   }
   if (hasGuestObjectState(value) || privateElements.has(value)) {
@@ -23065,7 +23165,7 @@ function indexHeapContainers(snapshot) {
     if (key === "version" || key === "sourceHash" || key === "heap") {
       continue;
     }
-    collectContainerStats(value, stats, ancestors, guestValues);
+    collectContainerStats(value, stats, ancestors, guestValues, inMemoryRunSnapshots.has(snapshot));
   }
   const heapIds = /* @__PURE__ */ new Map();
   let nextId = 1;
@@ -23077,7 +23177,7 @@ function indexHeapContainers(snapshot) {
   }
   return { heapIds, guestValues };
 }
-function collectContainerStats(value, stats, ancestors, guestValues, depth = 0) {
+function collectContainerStats(value, stats, ancestors, guestValues, trustedRunReplay, depth = 0) {
   if (value === null || typeof value !== "object") {
     return;
   }
@@ -23113,20 +23213,20 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
   }) } : isSandboxArrayBuffer(value) ? { kind: "arraybuffer", state: captureArrayBufferState(value, (entry) => {
     guestEntries.push(entry);
     return null;
-  }) } : captureGuestHeapNode(value, (entry) => {
+  }) } : trustedRunReplay && isSandboxPromise(value) && unrepresentedPromiseContinuations.has(value) ? void 0 : captureGuestHeapNode(value, (entry) => {
     guestEntries.push(entry);
     return null;
   });
   if (guest !== void 0) {
     if (!isSandboxArrayBuffer(value) && !isSandboxDataView(value) && !isNumericTypedArray(value)) guestValues.add(value);
     for (const entry of guestEntries) {
-      collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);
+      collectContainerStats(entry, stats, ancestors, guestValues, trustedRunReplay, depth + 1);
       if (entry !== null && typeof entry === "object") stats.get(entry).forceHeap = true;
     }
     ancestors.delete(value);
     return;
   }
-  for (const entry of guestEntries) collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);
+  for (const entry of guestEntries) collectContainerStats(entry, stats, ancestors, guestValues, trustedRunReplay, depth + 1);
   if (!Array.isArray(value) && !isPlainObject(value) && !isNumericTypedArray(value) && !isSandboxDate(value)) {
     ancestors.delete(value);
     return;
@@ -23136,12 +23236,12 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
     return "value" in descriptor ? [descriptor.value] : [];
   }) : isSandboxDate(value) ? dateDataProperties(value).flatMap(([key, descriptor]) => typeof key === "string" ? [descriptor.value] : []) : isSandboxBox(value) ? boxedDataProperties(value).map(([, descriptor]) => descriptor.value) : isSandboxArguments(value) ? getSandboxArgumentEntries(value).map(([, entry]) => entry) : getEnumerableDataValues(value);
   for (const entry of entries) {
-    collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);
+    collectContainerStats(entry, stats, ancestors, guestValues, trustedRunReplay, depth + 1);
   }
   for (const key of ownSerializableSymbolKeys(value)) {
     const descriptor = Object.getOwnPropertyDescriptor(value, key);
     if ("value" in descriptor)
-      collectContainerStats(descriptor.value, stats, ancestors, guestValues, depth + 1);
+      collectContainerStats(descriptor.value, stats, ancestors, guestValues, trustedRunReplay, depth + 1);
   }
   ancestors.delete(value);
 }
@@ -27726,7 +27826,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["intrinsic", "bound-function", "promise-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 (!["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"]);
@@ -27807,12 +27907,68 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     });
     return false;
   }
-  if (node.kind === "promise-resolver") {
-    fields(node, ["kind", "promise", "state"]);
-    reference(node.promise, ["guest-promise"]);
+  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.");
+    const source = reference(node.source, ["pending-promise", "promise-reaction", "guest-promise"]);
+    if (source === owner)
+      throw new TypeError("A promise cannot adopt itself.");
+    let matchingCallbacks = 0;
+    for (const entry of array(source.reactions)) {
+      const reaction = reference(entry, ["promise-reaction"]);
+      const handlers = [reaction.onFulfilled, reaction.onRejected].map((value) => {
+        if (value === null || typeof value !== "object" || record3(value).kind !== "ref") return void 0;
+        const handler = reference(value);
+        return handler.kind === "adoption-resolver" && reference(handler.bridge, ["promise-adoption"]) === node ? handler : void 0;
+      });
+      if (handlers.every((handler) => handler === void 0)) continue;
+      if (handlers[0]?.action !== "fulfilled" || handlers[1]?.action !== "rejected")
+        throw new TypeError("Invalid promise adoption callbacks.");
+      matchingCallbacks++;
+    }
+    if (matchingCallbacks !== 1) throw new TypeError("Invalid promise adoption callbacks.");
+  } else if (node.kind === "adoption-resolver") {
+    fields(node, ["kind", "bridge", "action"]);
+    reference(node.bridge, ["promise-adoption"]);
+    if (node.action !== "fulfilled" && node.action !== "rejected") throw new TypeError("Invalid adoption resolver action.");
+  } else if (node.kind === "promise-resolver") {
+    fields(node, ["kind", "promise", "state"], ["action"]);
+    const target = reference(node.promise, ["guest-promise", "pending-promise"]);
+    if ((target.kind === "pending-promise" || Object.hasOwn(node, "action")) && node.action !== "fulfilled" && node.action !== "rejected")
+      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"] : []);
+    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") {
+      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.");
+    }
+    if (!Array.isArray(node.reactions)) throw new TypeError("Invalid promise reactions.");
+    const reactions = /* @__PURE__ */ new Set();
+    for (const entry of node.reactions) {
+      const reaction = reference(entry, ["promise-reaction"]);
+      if (reactions.has(reaction)) throw new TypeError("Duplicate promise reaction.");
+      if (reference(reaction.source) !== node) throw new TypeError("Invalid promise reaction source.");
+      reactions.add(reaction);
+    }
     state(node.state);
   } else if (node.kind === "guest-promise") {
-    fields(node, ["kind", "status", "value", "state"]);
+    fields(node, ["kind", "status", "value", "state"], ["reactions"]);
+    if (Object.hasOwn(node, "reactions")) {
+      if (!Array.isArray(node.reactions)) throw new TypeError("Invalid promise reactions.");
+      const reactions = /* @__PURE__ */ new Set();
+      for (const entry of node.reactions) {
+        const reaction = reference(entry, ["promise-reaction"]);
+        if (reactions.has(reaction) || reference(reaction.source) !== node) throw new TypeError("Invalid promise reaction source.");
+        reactions.add(reaction);
+      }
+    }
     if (node.status !== "fulfilled" && node.status !== "rejected") throw new TypeError("Invalid guest promise settlement.");
     if (node.status === "fulfilled" && node.value !== null && typeof node.value === "object" && record3(node.value).kind === "ref" && reference(node.value) === node)
       throw new TypeError("A promise cannot fulfill with itself.");
@@ -28201,19 +28357,26 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
   }
   return true;
 }
-function validateGuestScopeParents(heap) {
-  const finished = /* @__PURE__ */ new Set();
-  for (const [id, raw] of Object.entries(heap)) {
-    if (record3(raw).kind !== "scope-frame" || finished.has(id)) continue;
-    const path = /* @__PURE__ */ new Set();
-    let current = id;
-    while (current !== void 0 && !finished.has(current)) {
-      if (path.has(current)) throw new TypeError("Cyclic guest scope parent graph.");
-      path.add(current);
-      const parent = record3(heap[current]).parent;
-      current = absent(parent) ? void 0 : String(record3(parent).id);
+function validateGuestHeapGraphs(heap) {
+  for (const [kind, edge, message] of [
+    ["scope-frame", "parent", "Cyclic guest scope parent graph."],
+    ["promise-reaction", "source", "Cyclic promise reaction source graph."]
+  ]) {
+    const finished = /* @__PURE__ */ new Set();
+    for (const [id, raw] of Object.entries(heap)) {
+      if (record3(raw).kind !== kind || finished.has(id)) continue;
+      const path = /* @__PURE__ */ new Set();
+      let current = id;
+      while (current !== void 0 && !finished.has(current)) {
+        if (path.has(current)) throw new TypeError(message);
+        const node = record3(heap[current]);
+        if (node.kind !== kind) break;
+        path.add(current);
+        const parent = node[edge];
+        current = absent(parent) ? void 0 : String(record3(parent).id);
+      }
+      for (const visited of path) finished.add(visited);
     }
-    for (const visited of path) finished.add(visited);
   }
 }
 
@@ -28597,7 +28760,7 @@ function validateDumpHeap(root, state) {
   }
   validateDumpReferences(root, "$", 0, state, heapIds, heap, "root");
   try {
-    validateGuestScopeParents(heap);
+    validateGuestHeapGraphs(heap);
   } catch (error) {
     fail("invalidCycle", "$.heap", error instanceof Error ? error.message : "invalid guest scope parent graph");
   }
@@ -30028,6 +30191,15 @@ function measureSandboxData(values, options = {}) {
     if (isSandboxPromise(value)) {
       const settlement = promiseStates.get(value);
       if (settlement !== void 0 && settlement.status !== "pending") visit(settlement.value, depth + 1);
+      const continuation = promiseContinuations.get(value);
+      if (continuation?.kind === "capability" && continuation.resolution !== void 0)
+        visit(continuation.resolution.value, depth + 1);
+      else if (continuation?.kind === "reaction") {
+        visit(continuation.source, depth + 1);
+        visit(continuation.onFulfilled, depth + 1);
+        visit(continuation.onRejected, depth + 1);
+      }
+      for (const reaction of promiseReactionResults.get(value) ?? []) visit(reaction, 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;
@@ -45043,4 +45215,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-6HQSVAXP.js.map
+//# sourceMappingURL=chunk-L4AQGNFP.js.map