@poe-platform/safe-js 0.1.277 → 0.1.279

package/dist/safe-js/chunks/{chunk-F6E3VH3T.js → chunk-B635E7GD.js}

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

package/dist/safe-js/chunks/{chunk-VDDR5KKE.js → chunk-OXTYSTLB.js}

@@ -11779,6 +11779,17 @@ function createPromiseGlobals(options) {
       guest: true,
       name: "reject",
       length: 1
+    }),
+    withResolvers: createSandboxClosure({
+      sandbox: true,
+      guest: true,
+      name: "withResolvers",
+      length: 0,
+      call: (_args, context) => createPromiseCapability(
+        context === void 0 ? promiseConstructor : context.thisValue,
+        options.budget,
+        context
+      )
     })
   };
   const promiseConstructor = createSandboxClosure({
@@ -12201,6 +12212,13 @@ function budgetSandboxValue(value, budget) {
   allocateSandboxValue(value, budget, /* @__PURE__ */ new WeakSet());
   return value;
 }
+function prepareAwaitedPromise(value, budget, context) {
+  if (!intrinsicPromiseConstructors.has(budget)) createPromiseGlobals({ budget });
+  const constructor = intrinsicPromiseConstructors.get(budget);
+  const actualConstructor = readPromiseProperty(value, "constructor", getPromisePrototype(budget), budget, context);
+  const finish = (actual) => actual === constructor ? value : createSandboxPromise(resolveSandboxValue(value, { budget, context }), { trackReplay: false });
+  return actualConstructor instanceof Promise ? actualConstructor.then(finish) : finish(actualConstructor);
+}
 function resolveSandboxValue(value, options = {}) {
   try {
     return resolveSandboxValueNow(value, options);
@@ -12618,16 +12636,18 @@ function registerCancelablePromises(value, signal) {
   }
 }
 function awaitSandboxValue(value, signal, budget, context) {
-  let resolved;
-  if (isSandboxPromise(value)) {
-    observeSandboxPromise(value);
-    const outcome = signal === void 0 ? value.promise : cancelableOutcomes.get(value)?.get(signal) ?? value.promise;
-    resolved = new Promise((resolve, reject) => {
+  if (!isSandboxPromise(value)) {
+    return interruptOnFatalPromiseRejection(awaitWithSignal(resolveSandboxValue(value, { budget, context }), signal));
+  }
+  const observe = (value2) => {
+    observeSandboxPromise(value2);
+    const outcome = signal === void 0 ? value2.promise : cancelableOutcomes.get(value2)?.get(signal) ?? value2.promise;
+    const resolved = new Promise((resolve, reject) => {
       const detach = onFatalPromiseRejection(reject);
       const complete = (state, result) => {
         detach?.();
         try {
-          consumeSettledHostCall(value);
+          consumeSettledHostCall(value2);
           if (state === "fulfilled") resolve(result);
           else reject(result);
         } catch (error) {
@@ -12639,11 +12659,15 @@ function awaitSandboxValue(value, signal, budget, context) {
         (reason) => complete("rejected", reason)
       );
     });
-  } else {
-    resolved = resolveSandboxValue(value, { budget, context });
+    return value2.synchronousPrefix !== void 0 || signal !== void 0 && cancelableOutcomes.get(value2)?.has(signal) ? resolved : awaitWithSignal(resolved, signal);
+  };
+  try {
+    assertPromiseExecutionAllowed();
+    const prepared = budget === void 0 ? value : prepareAwaitedPromise(value, budget, context);
+    return prepared instanceof Promise ? interruptOnFatalPromiseRejection(awaitWithSignal(prepared.then(observe), signal)) : observe(prepared);
+  } catch (error) {
+    return Promise.reject(error);
   }
-  const pending = isSandboxPromise(value) && (value.synchronousPrefix !== void 0 || signal !== void 0 && cancelableOutcomes.get(value)?.has(signal)) ? resolved : awaitWithSignal(resolved, signal);
-  return isSandboxPromise(value) ? pending : interruptOnFatalPromiseRejection(pending);
 }
 function awaitWithSignal(promise, signal) {
   if (signal === void 0) return Promise.resolve(promise);
@@ -40249,4 +40273,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-VDDR5KKE.js.map
+//# sourceMappingURL=chunk-OXTYSTLB.js.map