@poe-platform/safe-js 0.1.421 → 0.1.423

package/dist/safe-js/chunks/{chunk-VRRAQ6G5.js → chunk-MYKH5PM4.js}

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

package/dist/safe-js/chunks/{chunk-NNBQXEW4.js → chunk-V3XJABDF.js}

@@ -22615,6 +22615,59 @@ function callGeneratorMethod(target, method, value, budget, context, async) {
   return async ? createSandboxPromise(result) : result;
 }
 
+// packages/safe-js/src/interp/globals/async-iterator-dispose.ts
+function installAsyncIteratorDispose(prototype, budget) {
+  const promiseConstructor = getPromiseMember("constructor", budget);
+  const unwrap = createSandboxClosure({ guest: true, sandbox: true, name: "", length: 1, call: () => void 0 });
+  registerBuiltinIdentities(budget, { "%AsyncIteratorDisposeResult%": unwrap });
+  registerIntrinsicFunction(budget, unwrap);
+  const dispose = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "[Symbol.asyncDispose]",
+    length: 0,
+    call: (_args, context) => {
+      let completePrefix;
+      let failPrefix;
+      const prefix = new Promise((resolve, reject) => {
+        completePrefix = resolve;
+        failPrefix = reject;
+      });
+      const capability = createPendingPromiseCapability(budget, context, prefix);
+      void (async () => {
+        try {
+          const receiver = context?.thisValue;
+          if (receiver === null || receiver === void 0) throw new TypeError("Cannot read return from a nullish receiver.");
+          const method = await read(receiver, "return", context);
+          if (method === void 0 || method === null) {
+            await capability.resolve.call([], context);
+            return;
+          }
+          if (!isSandboxClosure(method)) throw new TypeError("Iterator return must be callable.");
+          const result = await invokeBuiltinClosure(method, [], budget, context, receiver);
+          if (isSandboxPromise(result) && await read(result, "constructor", context) === promiseConstructor) {
+            attachPendingPromiseReaction(result, capability, unwrap, void 0, budget, context);
+          } else {
+            const wrapper = createPendingPromiseCapability(budget, context);
+            attachPendingPromiseReaction(wrapper.promise, capability, unwrap, void 0, budget, context);
+            await wrapper.resolve.call([result], context);
+          }
+        } catch (error) {
+          await capability.reject.call([createThrowCompletion(error, budget, context?.stack ?? []).value], context);
+        }
+      })().then(completePrefix, failPrefix);
+      return capability.promise;
+    }
+  });
+  Object.defineProperty(prototype, wellKnownSymbols.asyncDispose, { value: dispose, writable: true, configurable: true });
+  registerIntrinsicFunction(budget, dispose);
+  async function read(value, key, context) {
+    if (context?.getProperty !== void 0) return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+  }
+}
+
 // packages/safe-js/src/interp/globals/generator.ts
 function createGeneratorPrototypes(budget) {
   const asyncIteratorPrototype = /* @__PURE__ */ Object.create(null);
@@ -22631,6 +22684,7 @@ function createGeneratorPrototypes(budget) {
     configurable: true
   });
   setSandboxPrototype(asyncIteratorPrototype, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
+  installAsyncIteratorDispose(asyncIteratorPrototype, budget);
   registerBuiltinIdentities(budget, { "%AsyncIteratorPrototype%": asyncIteratorPrototype });
   registerIntrinsicObject(budget, asyncIteratorPrototype);
   registerIntrinsicFunction(budget, asyncIterator);
@@ -23042,6 +23096,23 @@ function createIteratorGlobal(budget) {
   Object.defineProperty(prototype, "constructor", { get: accessorAdapter(getter, "get"), set: accessorAdapter(setter, "set"), configurable: true });
   registerIntrinsicFunction(budget, getter);
   registerIntrinsicFunction(budget, setter);
+  const dispose = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "[Symbol.dispose]",
+    length: 0,
+    call: async (_args, context) => {
+      const receiver = context?.thisValue;
+      if (receiver === null || receiver === void 0) throw new TypeError("Cannot read return from a nullish receiver.");
+      const method = context?.getProperty !== void 0 ? await context.getProperty(receiver, "return") : await readPropertyDescriptor(getSandboxPropertyDescriptor(receiver, "return", budget) ?? { value: void 0 }, receiver, context);
+      if (method === void 0 || method === null) return void 0;
+      if (!isSandboxClosure(method)) throw new TypeError("Iterator return must be callable.");
+      await invokeBuiltinClosure(method, [], budget, context, receiver);
+      return void 0;
+    }
+  });
+  Object.defineProperty(prototype, wellKnownSymbols.dispose, { value: dispose, writable: true, configurable: true });
+  registerIntrinsicFunction(budget, dispose);
   installIteratorFrom(constructor, budget);
   installIteratorConsumers(prototype, budget);
   installLazyIteratorHelpers(prototype, budget);
@@ -46145,4 +46216,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-NNBQXEW4.js.map
+//# sourceMappingURL=chunk-V3XJABDF.js.map