@poe-platform/safe-js 0.1.270 → 0.1.272

package/dist/safe-js/chunks/{chunk-RKESZ3RE.js → chunk-3ANG72OY.js}

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

package/dist/safe-js/chunks/{chunk-JJRD6D25.js → chunk-5AXKUJ6N.js}

@@ -11677,87 +11677,108 @@ function createPromiseGlobals(options) {
     }
     return pending;
   };
+  const species = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "get [Symbol.species]",
+    length: 0,
+    call: (_args, context) => context?.thisValue
+  });
+  const properties = {
+    prototype,
+    all: createSandboxClosure({
+      sandbox: true,
+      call: ([values], context) => settleIterable(
+        values,
+        "all",
+        options.budget,
+        context === void 0 ? promiseConstructor : context.thisValue,
+        context
+      ),
+      name: "all"
+    }),
+    race: createSandboxClosure({
+      sandbox: true,
+      call: ([values], context) => settleIterable(
+        values,
+        "race",
+        options.budget,
+        context === void 0 ? promiseConstructor : context.thisValue,
+        context
+      ),
+      name: "race"
+    }),
+    allSettled: createSandboxClosure({
+      sandbox: true,
+      call: ([values], context) => settleIterable(
+        values,
+        "allSettled",
+        options.budget,
+        context === void 0 ? promiseConstructor : context.thisValue,
+        context
+      ),
+      name: "allSettled"
+    }),
+    any: createSandboxClosure({
+      sandbox: true,
+      call: ([values], context) => settleIterable(
+        values,
+        "any",
+        options.budget,
+        context === void 0 ? promiseConstructor : context.thisValue,
+        context
+      ),
+      name: "any"
+    }),
+    resolve: createSandboxClosure({
+      sandbox: true,
+      call: ([value], context) => {
+        const constructor = context === void 0 ? promiseConstructor : context.thisValue;
+        if (typeof constructor !== "object" || constructor === null) {
+          throw new TypeError("Promise.resolve requires an object receiver.");
+        }
+        const finish = (actualConstructor2) => {
+          if (isSandboxPromise(value) && actualConstructor2 === constructor) return value;
+          return isSandboxPromiseConstructor(constructor) ? createSandboxPromise(resolveSandboxValue(value, { budget: options.budget })) : settleConstructedPromise(constructor, value, "fulfilled", options.budget, context);
+        };
+        if (!isSandboxPromise(value)) return finish(void 0);
+        const descriptor = getSandboxPropertyDescriptor(value, "constructor", options.budget);
+        const actualConstructor = descriptor === void 0 ? getPromiseMember("constructor", options.budget) : readPropertyDescriptor(descriptor, value, context, true);
+        return actualConstructor instanceof Promise ? actualConstructor.then(finish) : finish(actualConstructor);
+      },
+      name: "resolve"
+    }),
+    reject: createSandboxClosure({
+      sandbox: true,
+      call: ([reason], context) => {
+        const constructor = context === void 0 ? promiseConstructor : context.thisValue;
+        return isSandboxPromiseConstructor(constructor) ? createRejectedSandboxPromise(reason, options.budget, context?.span) : settleConstructedPromise(constructor, reason, "rejected", options.budget, context);
+      },
+      name: "reject"
+    })
+  };
   const promiseConstructor = createSandboxClosure({
+    guest: true,
     sandbox: true,
     name: "Promise",
+    length: 1,
     construct,
     call: () => {
       throw new TypeError("Constructor Promise requires 'new'.");
-    },
-    properties: {
-      prototype,
-      all: createSandboxClosure({
-        sandbox: true,
-        call: ([values], context) => settleIterable(
-          values,
-          "all",
-          options.budget,
-          context === void 0 ? promiseConstructor : context.thisValue,
-          context
-        ),
-        name: "all"
-      }),
-      race: createSandboxClosure({
-        sandbox: true,
-        call: ([values], context) => settleIterable(
-          values,
-          "race",
-          options.budget,
-          context === void 0 ? promiseConstructor : context.thisValue,
-          context
-        ),
-        name: "race"
-      }),
-      allSettled: createSandboxClosure({
-        sandbox: true,
-        call: ([values], context) => settleIterable(
-          values,
-          "allSettled",
-          options.budget,
-          context === void 0 ? promiseConstructor : context.thisValue,
-          context
-        ),
-        name: "allSettled"
-      }),
-      any: createSandboxClosure({
-        sandbox: true,
-        call: ([values], context) => settleIterable(
-          values,
-          "any",
-          options.budget,
-          context === void 0 ? promiseConstructor : context.thisValue,
-          context
-        ),
-        name: "any"
-      }),
-      resolve: createSandboxClosure({
-        sandbox: true,
-        call: ([value], context) => {
-          const constructor = context === void 0 ? promiseConstructor : context.thisValue;
-          if (typeof constructor !== "object" || constructor === null) {
-            throw new TypeError("Promise.resolve requires an object receiver.");
-          }
-          const finish = (actualConstructor2) => {
-            if (isSandboxPromise(value) && actualConstructor2 === constructor) return value;
-            return isSandboxPromiseConstructor(constructor) ? createSandboxPromise(resolveSandboxValue(value, { budget: options.budget })) : settleConstructedPromise(constructor, value, "fulfilled", options.budget, context);
-          };
-          if (!isSandboxPromise(value)) return finish(void 0);
-          const descriptor = getSandboxPropertyDescriptor(value, "constructor", options.budget);
-          const actualConstructor = descriptor === void 0 ? getPromiseMember("constructor", options.budget) : readPropertyDescriptor(descriptor, value, context, true);
-          return actualConstructor instanceof Promise ? actualConstructor.then(finish) : finish(actualConstructor);
-        },
-        name: "resolve"
-      }),
-      reject: createSandboxClosure({
-        sandbox: true,
-        call: ([reason], context) => {
-          const constructor = context === void 0 ? promiseConstructor : context.thisValue;
-          return isSandboxPromiseConstructor(constructor) ? createRejectedSandboxPromise(reason, options.budget, context?.span) : settleConstructedPromise(constructor, reason, "rejected", options.budget, context);
-        },
-        name: "reject"
-      })
     }
   });
+  const constructorProperties = materializeFunctionProperties(promiseConstructor);
+  for (const [key, value] of Object.entries(properties)) {
+    Object.defineProperty(constructorProperties, key, {
+      value,
+      writable: key !== "prototype",
+      configurable: key !== "prototype"
+    });
+  }
+  Object.defineProperty(constructorProperties, Symbol.species, {
+    get: accessorAdapter(species, "get"),
+    configurable: true
+  });
   Object.defineProperty(prototype, "constructor", {
     value: promiseConstructor,
     writable: true,
@@ -11765,9 +11786,12 @@ function createPromiseGlobals(options) {
   });
   promiseConstructors.add(promiseConstructor);
   intrinsicPromiseConstructors.set(options.budget, promiseConstructor);
+  registerIntrinsicFunction(options.budget, species);
+  registerIntrinsicFunction(options.budget, promiseConstructor);
   return { Promise: promiseConstructor };
 }
 function getPromiseMember(property, budget) {
+  if (!intrinsicPromiseConstructors.has(budget)) createPromiseGlobals({ budget });
   const prototype = getPromisePrototype(budget);
   return Object.hasOwn(prototype, property) ? prototype[property] : void 0;
 }
@@ -11842,21 +11866,40 @@ function getPromisePrototype(budget) {
         const target = context?.thisValue;
         if (!isSandboxPromise(target))
           throw new TypeError("Promise.then requires a promise receiver.");
-        validatePromiseConstructorProperty(target, prototype);
-        observeSandboxPromise(target);
-        const chained = createSandboxPromise(
-          target.promise.then(
-            (value) => {
-              consumeSettledHostCall(target);
-              return runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained, context);
-            },
-            (reason) => {
-              consumeSettledHostCall(target);
-              return runPromiseReaction(onRejected, reason, "rejected", budget, chained, context);
-            }
-          )
-        );
-        return chained;
+        const finish = (constructor2) => {
+          if (!isSandboxPromiseConstructor(constructor2)) {
+            return createPromiseCapability(constructor2, budget, context).then((capability) => {
+              observeSandboxPromise(target);
+              createSandboxPromise(target.promise.then(
+                (value) => {
+                  consumeSettledHostCall(target);
+                  return runCapabilityReaction(onFulfilled, value, "fulfilled", capability, budget, context);
+                },
+                (reason) => {
+                  consumeSettledHostCall(target);
+                  return runCapabilityReaction(onRejected, reason, "rejected", capability, budget, context);
+                }
+              ));
+              return capability.promise;
+            });
+          }
+          observeSandboxPromise(target);
+          const chained = createSandboxPromise(
+            target.promise.then(
+              (value) => {
+                consumeSettledHostCall(target);
+                return runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained, context);
+              },
+              (reason) => {
+                consumeSettledHostCall(target);
+                return runPromiseReaction(onRejected, reason, "rejected", budget, chained, context);
+              }
+            )
+          );
+          return chained;
+        };
+        const constructor = getPromiseSpeciesConstructor(target, prototype, budget, context);
+        return constructor instanceof Promise ? constructor.then(finish) : finish(constructor);
       },
       name: "then"
     }),
@@ -11887,13 +11930,13 @@ function getPromisePrototype(budget) {
         if (typeof target !== "object" || target === null) {
           throw new TypeError("Promise.finally requires an object receiver.");
         }
-        const invoke = (then) => {
+        const invoke = (then, constructor2) => {
           if (!isSandboxClosure(then))
             throw new TypeError("Promise.finally requires a callable then.");
           const handlers = isSandboxClosure(onFinally) ? ["fulfilled", "rejected"].map(
             (state) => createSandboxClosure({
               sandbox: true,
-              retainedValues: () => [onFinally],
+              retainedValues: () => [onFinally, constructor2],
               call: async ([value]) => {
                 const result = await callPromiseClosure(
                   onFinally,
@@ -11902,8 +11945,16 @@ function getPromisePrototype(budget) {
                   budget,
                   context
                 );
-                const pending = isSandboxPromise(result) && getPromiseMember("constructor", budget) === intrinsicPromiseConstructors.get(budget) ? result : createSandboxPromise(resolveSandboxValue(result, { budget }));
-                const cleanupThen = getPromiseMember("then", budget);
+                let pending;
+                const actualConstructor = isSandboxPromise(result) ? await readPromiseProperty(result, "constructor", prototype, budget, context) : void 0;
+                if (isSandboxPromise(result) && actualConstructor === constructor2) {
+                  pending = result;
+                } else if (isSandboxPromiseConstructor(constructor2)) {
+                  pending = createSandboxPromise(resolveSandboxValue(result, { budget }));
+                } else {
+                  pending = await settleConstructedPromise(constructor2, result, "fulfilled", budget, context);
+                }
+                const cleanupThen = await readPromiseProperty(pending, "then", prototype, budget, context);
                 if (!isSandboxClosure(cleanupThen))
                   throw new TypeError("Promise cleanup requires a callable then.");
                 return callPromiseClosure(
@@ -11932,13 +11983,13 @@ function getPromisePrototype(budget) {
             newTarget: void 0
           });
         };
-        const finish = () => {
+        const finish = (constructor2) => {
           const descriptor = getSandboxPropertyDescriptor(target, "then", budget);
           const then = descriptor === void 0 ? readPromiseReceiverProperty(target, "then", prototype, context) : readPropertyDescriptor(descriptor, target, context, true);
-          return then instanceof Promise ? then.then(invoke) : invoke(then);
+          return then instanceof Promise ? then.then((method) => invoke(method, constructor2)) : invoke(then, constructor2);
         };
-        const validation = validatePromiseConstructorProperty(target, prototype, context);
-        return validation instanceof Promise ? validation.then(finish) : finish();
+        const constructor = getPromiseSpeciesConstructor(target, prototype, budget, context);
+        return constructor instanceof Promise ? constructor.then(finish) : finish(constructor);
       },
       name: "finally"
     })
@@ -11955,14 +12006,32 @@ function readPromiseReceiverProperty(receiver, property, prototype, context) {
   const properties = isSandboxPromise(receiver) ? prototype : isSandboxClosure(receiver) ? receiver.properties : receiver;
   return typeof properties === "object" && properties !== null && Object.hasOwn(properties, property) ? properties[property] : void 0;
 }
-function validatePromiseConstructorProperty(receiver, prototype, context) {
+function getPromiseSpeciesConstructor(receiver, prototype, budget, context) {
+  const defaultConstructor = intrinsicPromiseConstructors.get(budget);
   const validate = (constructor2) => {
-    if (constructor2 !== void 0 && (typeof constructor2 !== "object" || constructor2 === null))
+    if (constructor2 === void 0) return defaultConstructor;
+    if (typeof constructor2 !== "object" || constructor2 === null)
       throw new TypeError("Promise constructor property must be an object.");
+    const finish = (species2) => {
+      if (species2 === void 0 || species2 === null) return defaultConstructor;
+      if (!isSandboxClosure(species2) || species2.construct === void 0)
+        throw new TypeError("Promise species must be a constructor.");
+      return species2;
+    };
+    const species = readPromiseProperty(constructor2, Symbol.species, prototype, budget, context);
+    return species instanceof Promise ? species.then(finish) : finish(species);
   };
-  const constructor = readPromiseReceiverProperty(receiver, "constructor", prototype, context);
+  const constructor = readPromiseProperty(receiver, "constructor", prototype, budget, context);
   return constructor instanceof Promise ? constructor.then(validate) : validate(constructor);
 }
+function readPromiseProperty(receiver, property, prototype, budget, context) {
+  const descriptor = getSandboxPropertyDescriptor(receiver, property, budget);
+  if (descriptor !== void 0 && !("value" in descriptor) && context?.invokeClosure === void 0) {
+    const getter = accessorClosure(descriptor.get);
+    return getter?.call([], { ...context, stack: context?.stack ?? [], thisValue: receiver });
+  }
+  return descriptor === void 0 ? typeof property === "string" ? readPromiseReceiverProperty(receiver, property, prototype, context) : void 0 : readPropertyDescriptor(descriptor, receiver, context, true);
+}
 async function settleIterable(iterable, method, budget, constructor, context) {
   const capability = await createPromiseCapability(constructor, budget, context);
   const prototype = getPromisePrototype(budget);
@@ -12213,6 +12282,35 @@ function resolveThenable(value, then, options) {
     ).catch(reject);
   });
 }
+function runCapabilityReaction(handler, value, state, capability, budget, context) {
+  return runPromiseJob(async () => {
+    if (value instanceof SandboxError && (value.code === "budgetExceeded" || value.code === "reentry")) {
+      throw value;
+    }
+    let completion = state;
+    let result = state === "rejected" && value instanceof Error ? coerceThrownValue(value, budget, []) : value;
+    if (isSandboxClosure(handler)) {
+      try {
+        result = await callPromiseClosure(handler, [result], void 0, budget, context);
+        completion = "fulfilled";
+      } catch (error) {
+        if (error instanceof SandboxError && (error.code === "budgetExceeded" || error.code === "reentry")) {
+          throw error;
+        }
+        completion = "rejected";
+        result = error;
+      }
+    }
+    await callPromiseClosure(
+      completion === "fulfilled" ? capability.resolve : capability.reject,
+      [result],
+      void 0,
+      budget,
+      context
+    );
+    return void 0;
+  });
+}
 function runPromiseReaction(handler, value, state, budget, self, context) {
   return new Promise((resolve, reject) => {
     if (state === "rejected" && value instanceof SandboxError && (value.code === "budgetExceeded" || value.code === "reentry")) {
@@ -40102,4 +40200,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-JJRD6D25.js.map
+//# sourceMappingURL=chunk-5AXKUJ6N.js.map