@poe-platform/safe-js 0.1.406 → 0.1.408

package/dist/safe-js/chunks/{chunk-XY5ZPK3G.js → chunk-6GFX7QAK.js}

@@ -8812,6 +8812,9 @@ async function flushPromiseJobs() {
 var promiseStates = /* @__PURE__ */ new WeakMap();
 
 // packages/safe-js/src/interp/promise-continuations.ts
+var thenableContinuations = /* @__PURE__ */ new WeakMap();
+var thenableStates = /* @__PURE__ */ new WeakMap();
+var thenableResolvers = /* @__PURE__ */ new WeakMap();
 var promiseCapabilityExecutors = /* @__PURE__ */ new WeakMap();
 var promiseAggregateHandlers = /* @__PURE__ */ new WeakMap();
 var promiseAggregateStates = /* @__PURE__ */ new WeakMap();
@@ -21313,15 +21316,23 @@ function createPendingPromiseCapability(budget, context) {
         if (resolverState.settled) return void 0;
         resolverState.settled = true;
         continuation.resolution = { status, value };
+        let prefix;
         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 }));
+          else fulfill(resolveSandboxValue(value, {
+            budget,
+            self: promise,
+            context,
+            onSynchronousPrefix: (pending) => {
+              prefix = pending;
+            }
+          }));
         } catch (error) {
           reject(error);
         }
-        return void 0;
+        return prefix;
       }
     });
     promiseResolvingFunctions.set(resolver, resolverState);
@@ -21427,7 +21438,12 @@ function createPromiseGlobals(options) {
         }
         const finish = (actualConstructor2) => {
           if (isSandboxPromise(value) && actualConstructor2 === constructor) return value;
-          return isSandboxPromiseConstructor(constructor) ? createSandboxPromise(resolveSandboxValue(value, { budget: options.budget, context })) : settleConstructedPromise(constructor, value, "fulfilled", options.budget, context);
+          if (isSandboxPromiseConstructor(constructor)) {
+            const capability = createPendingPromiseCapability(options.budget, context);
+            const prefix = capability.resolve.call([value], context);
+            return prefix instanceof Promise ? prefix.then(() => capability.promise) : capability.promise;
+          }
+          return settleConstructedPromise(constructor, value, "fulfilled", options.budget, context);
         };
         if (!isSandboxPromise(value)) return finish(void 0);
         const descriptor = getSandboxPropertyDescriptor(value, "constructor", options.budget);
@@ -21993,10 +22009,27 @@ function resolveSandboxValueNow(value, options) {
     );
   }
   const then = getThenable(value, options.budget);
-  if (then instanceof Promise)
-    return then.then(
-      (method) => method === void 0 ? budgetIfNeeded(value, options.budget) : resolveThenable(value, method, options)
-    );
+  if (then instanceof Promise) {
+    let fulfill;
+    let reject;
+    const resolved = new Promise((resolve, fail2) => {
+      fulfill = resolve;
+      reject = fail2;
+    });
+    const prefix = then.then((method) => {
+      try {
+        fulfill(method === void 0 ? budgetIfNeeded(value, options.budget) : resolveThenable(value, method, options));
+      } catch (error) {
+        reject(error);
+      }
+      return void 0;
+    }, (error) => {
+      reject(error);
+      return void 0;
+    });
+    options.onSynchronousPrefix?.(prefix);
+    return resolved;
+  }
   if (then !== void 0) {
     return resolveThenable(value, then, options);
   }
@@ -22006,72 +22039,85 @@ function resolveThenable(value, then, options) {
   if (typeof value !== "object" || value === null) {
     return Promise.resolve(budgetIfNeeded(value, options.budget));
   }
-  return new Promise((resolve, reject) => {
-    let settlement;
-    let completed = false;
-    let invocationPending = true;
-    const complete2 = () => {
-      if (completed || invocationPending || settlement === void 0) return;
-      completed = true;
-      try {
-        if (settlement.state === "fulfilled") {
-          resolve(
-            requiresPromiseResolution(settlement.value, options.budget) ? resolveSandboxValueNow(settlement.value, options) : budgetIfNeeded(settlement.value, options.budget)
-          );
-        } else {
-          reject(budgetIfNeeded(settlement.value, options.budget));
-        }
-      } catch (error) {
-        reject(error);
+  const state = {
+    source: value,
+    owner: options.self,
+    settlement: void 0,
+    completed: false,
+    invocationPending: true
+  };
+  const bridge = createThenableBridge(state, options);
+  callInPromiseJob(then, bridge.resolvers, value, bridge.invocation, options.context).catch(bridge.rejectNative);
+  return bridge.promise;
+}
+function createThenableBridge(state, options) {
+  thenableStates.set(state, state);
+  let resolve;
+  let reject;
+  const promise = new Promise((fulfill, fail2) => {
+    resolve = fulfill;
+    reject = fail2;
+  });
+  if (state.owner !== void 0 && !state.completed) thenableContinuations.set(state.owner, state);
+  const complete2 = () => {
+    if (state.completed || state.invocationPending || state.settlement === void 0) return;
+    state.completed = true;
+    try {
+      if (state.settlement.state === "fulfilled") {
+        resolve(
+          requiresPromiseResolution(state.settlement.value, options.budget) ? resolveSandboxValueNow(state.settlement.value, { ...options, self: state.owner }) : budgetIfNeeded(state.settlement.value, options.budget)
+        );
+      } else {
+        reject(budgetIfNeeded(state.settlement.value, options.budget));
       }
-    };
-    const recordSettlement = (state, settledValue) => {
-      if (settlement !== void 0) {
-        return;
+    } catch (error) {
+      reject(error);
+    }
+  };
+  const recordSettlement = (status, settledValue) => {
+    if (state.settlement !== void 0) {
+      return;
+    }
+    state.settlement = { state: status, value: settledValue };
+    queueMicrotask(complete2);
+  };
+  const resolvers = ["fulfilled", "rejected"].map((action) => {
+    const resolver = createSandboxClosure({
+      sandbox: true,
+      guest: true,
+      name: "",
+      length: 1,
+      retainedValues: () => [state.source, state.owner, state.settlement?.value],
+      call: ([settledValue]) => {
+        recordSettlement(action, settledValue);
+        return void 0;
       }
-      settlement = { state, value: settledValue };
-      queueMicrotask(complete2);
-    };
-    callInPromiseJob(
-      then,
-      [
-        createSandboxClosure({
-          sandbox: true,
-          call: ([resolved]) => {
-            recordSettlement("fulfilled", resolved);
-            return void 0;
-          },
-          name: "resolve"
-        }),
-        createSandboxClosure({
-          sandbox: true,
-          call: ([reason]) => {
-            recordSettlement("rejected", reason);
-            return void 0;
-          },
-          name: "reject"
-        })
-      ],
-      value,
-      {
-        fulfilled: () => {
-          invocationPending = false;
-          complete2();
-        },
-        rejected: (error) => {
-          invocationPending = false;
-          if (error instanceof SandboxError && (error.code === "budgetExceeded" || error.code === "reentry")) {
-            completed = true;
-            reject(error);
-            return;
-          }
-          recordSettlement("rejected", error);
-          complete2();
-        }
-      },
-      options.context
-    ).catch(reject);
+    });
+    thenableResolvers.set(resolver, { continuation: state, action });
+    return resolver;
   });
+  const invocation = {
+    fulfilled: () => {
+      state.invocationPending = false;
+      complete2();
+    },
+    rejected: (error) => {
+      state.invocationPending = false;
+      if (error instanceof SandboxError && (error.code === "budgetExceeded" || error.code === "reentry")) {
+        state.completed = true;
+        reject(error);
+        return;
+      }
+      recordSettlement("rejected", error);
+      complete2();
+    }
+  };
+  const release = () => {
+    if (state.owner !== void 0 && thenableContinuations.get(state.owner) === state)
+      thenableContinuations.delete(state.owner);
+  };
+  promise.then(release, release);
+  return { state, promise, resolvers, invocation, rejectNative: reject };
 }
 function runCapabilityReaction(handler, value, state, capability, budget, context) {
   return runPromiseJob(async () => {
@@ -22300,6 +22346,10 @@ function isPromiseLike2(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" && !isSandboxClosure(value) && !isSandboxPromise(value);
 }
 
+// packages/safe-js/src/snapshot/not-ready.ts
+var SnapshotNotReadyError = class extends TypeError {
+};
+
 // packages/safe-js/src/interp/symbol-registry.ts
 var symbolRegistryOrigins = /* @__PURE__ */ new WeakMap();
 
@@ -22442,6 +22492,25 @@ function captureGuestHeapNode(value, encode) {
   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 thenable = thenableStates.get(value);
+  if (thenable !== void 0) {
+    if (thenable.invocationPending || !thenable.completed && thenable.settlement !== void 0)
+      throw new SnapshotNotReadyError("Cannot serialize an active thenable invocation or settlement.");
+    return {
+      kind: "thenable-state",
+      source: encode(thenable.source),
+      owner: encode(thenable.owner),
+      completed: thenable.completed,
+      ...thenable.settlement === void 0 ? {} : { settlement: { state: thenable.settlement.state, value: encode(thenable.settlement.value) } }
+    };
+  }
+  const thenableResolver = isSandboxClosure(value) ? thenableResolvers.get(value) : void 0;
+  if (thenableResolver !== void 0) return {
+    kind: "thenable-resolver",
+    continuation: encode(thenableResolver.continuation),
+    action: thenableResolver.action,
+    state: captureObjectState(value, encode)
+  };
   const bridge = promiseAdoptionBridges.get(value);
   if (bridge !== void 0) {
     if (bridge.settled || bridge.owner === void 0) return void 0;
@@ -22477,6 +22546,15 @@ function captureGuestHeapNode(value, encode) {
     if (unrepresentedPromiseContinuations.has(value))
       throw new TypeError("Cannot serialize host reference: unrepresented promise continuation.");
     if (continuation?.kind === "capability") {
+      const thenable2 = thenableContinuations.get(value);
+      if (continuation.state.settled && thenable2 !== void 0 && !thenable2.completed && thenable2.owner === value)
+        return {
+          kind: "pending-promise",
+          thenable: encode(thenable2),
+          ...producerState,
+          reactions: [...promiseReactionResults.get(value) ?? []].map(encode),
+          state: captureObjectState(value, encode)
+        };
       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;
@@ -27960,7 +28038,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["construction-environment", "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;
+  if (!["thenable-state", "thenable-resolver", "construction-environment", "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"]);
@@ -27971,7 +28049,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
   };
   const callable = (value) => {
     if (absent(value)) return;
-    const target = reference(value, ["aggregate-handler", "capability-executor", "intrinsic", "bound-function", "promise-resolver", "guest-function", "guest-class"]);
+    const target = reference(value, ["thenable-resolver", "aggregate-handler", "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.");
   };
@@ -28052,7 +28130,26 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     });
     return false;
   }
-  if (node.kind === "construction-environment") {
+  if (node.kind === "thenable-state") {
+    fields(node, ["kind", "source", "owner", "completed"], ["settlement"]);
+    reference(node.source);
+    if (!absent(node.owner)) {
+      const owner = reference(node.owner, ["pending-promise", "promise-reaction", "guest-promise"]);
+      if (node.completed === false && (owner.kind !== "pending-promise" || owner.thenable === void 0 || reference(owner.thenable, ["thenable-state"]) !== node)) throw new TypeError("Invalid thenable owner linkage.");
+    }
+    if (typeof node.completed !== "boolean" || node.completed !== Object.hasOwn(node, "settlement"))
+      throw new TypeError("Invalid thenable settlement phase.");
+    if (node.settlement !== void 0) {
+      const settlement = record3(node.settlement);
+      fields(settlement, ["state", "value"]);
+      if (settlement.state !== "fulfilled" && settlement.state !== "rejected") throw new TypeError("Invalid thenable settlement status.");
+    }
+  } else if (node.kind === "thenable-resolver") {
+    fields(node, ["kind", "continuation", "action", "state"]);
+    reference(node.continuation, ["thenable-state"]);
+    if (node.action !== "fulfilled" && node.action !== "rejected") throw new TypeError("Invalid thenable resolver action.");
+    state(node.state);
+  } else if (node.kind === "construction-environment") {
     fields(node, ["kind", "constructor", "newTarget", "prototype", "thisValue", "thisScope", "initialized"]);
     const owner = reference(node.constructor, ["guest-class"]);
     callable(node.newTarget);
@@ -28128,7 +28225,12 @@ 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", "aggregate", "producers"]);
+    fields(node, node.kind === "pending-promise" ? ["kind", "reactions", "state"] : ["kind", "source", "onFulfilled", "onRejected", "reactions", "state"], node.kind === "pending-promise" ? ["adoption", "thenable", "producers"] : ["capability", "aggregate", "producers"]);
+    if (node.kind === "pending-promise" && Object.hasOwn(node, "thenable")) {
+      const continuation = reference(node.thenable, ["thenable-state"]);
+      if (Object.hasOwn(node, "adoption") || continuation.completed !== false || reference(continuation.owner) !== node)
+        throw new TypeError("Invalid thenable promise owner.");
+    }
     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.");
@@ -28984,7 +29086,7 @@ function validateDumpHeap(root, state) {
     fail("invalidCycle", "$.heap", error instanceof Error ? error.message : "invalid guest scope parent graph");
   }
 }
-function validateDumpReferences(value, path, depth, state, heapIds, heap, role = "data", allowScopeReference = false, allowConstructionReference = false) {
+function validateDumpReferences(value, path, depth, state, heapIds, heap, role = "data", allowScopeReference = false, allowConstructionReference = false, allowThenableReference = false) {
   if (value === null || typeof value !== "object") return;
   if (depth > state.limits.maxDepth)
     fail("budgetExceeded", path, `exceeds nesting limit ${state.limits.maxDepth}`);
@@ -29002,6 +29104,8 @@ function validateDumpReferences(value, path, depth, state, heapIds, heap, role =
       fail("invalidValue", path, "Internal scopes cannot be guest data");
     if (heap[String(id)].kind === "construction-environment" && !allowConstructionReference)
       fail("invalidValue", path, "Internal construction environments cannot be guest data");
+    if (heap[String(id)].kind === "thenable-state" && !allowThenableReference)
+      fail("invalidValue", path, "Internal thenable states cannot be guest data");
   }
   for (const [key, entry] of Object.entries(record4)) {
     const childRole = role === "root" && key === "heap" ? "heap" : role === "heap" ? "heap-node" : role === "heap-node" && (record4.kind === "guest-function" || record4.kind === "guest-generator") && key === "environment" ? "function-environment" : role === "heap-node" && record4.kind === "guest-generator" && key === "blockScopes" ? "scope-map" : role === "heap-node" && record4.kind === "guest-generator" && key === "expressionStates" ? "expressions" : role === "expressions" ? "expression" : "data";
@@ -29015,7 +29119,8 @@ function validateDumpReferences(value, path, depth, state, heapIds, heap, role =
       heap,
       childRole,
       scopeField,
-      role === "function-environment" && key === "construction"
+      role === "function-environment" && key === "construction",
+      role === "heap-node" && (record4.kind === "thenable-resolver" && key === "continuation" || record4.kind === "pending-promise" && key === "thenable")
     );
   }
 }
@@ -30338,10 +30443,20 @@ function measureSandboxData(values, options = {}) {
         }
         return;
       }
-      for (let index = 0; index < value.length; index += 1) {
-        const descriptor = Object.getOwnPropertyDescriptor(value, index);
-        if (descriptor !== void 0 && "value" in descriptor) visit(descriptor.value, depth + 1);
+      const elements = [];
+      if (nodeTypes.isProxy(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+          const descriptor = Object.getOwnPropertyDescriptor(value, index);
+          if (descriptor !== void 0 && "value" in descriptor) elements.push(descriptor.value);
+        }
+      } else {
+        for (const key of Object.getOwnPropertyNames(value)) {
+          if (!isArrayIndexKey2(key)) continue;
+          const descriptor = Object.getOwnPropertyDescriptor(value, key);
+          if (descriptor !== void 0 && "value" in descriptor) elements.push(descriptor.value);
+        }
       }
+      for (const element of elements) visit(element, depth + 1);
       return;
     }
     if (isSandboxMap(value) || isSandboxSet(value)) {
@@ -44382,6 +44497,7 @@ function createDumpController(lifecycle) {
     try {
       settlePendingRequest(serializeRunSnapshot(snapshot));
     } catch (error) {
+      if (!finished && error instanceof SnapshotNotReadyError) return;
       pendingRequest?.reject(error);
       pendingRequest = void 0;
     }
@@ -45452,4 +45568,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-XY5ZPK3G.js.map
+//# sourceMappingURL=chunk-6GFX7QAK.js.map