@poe-platform/safe-js 0.1.389 → 0.1.391

package/dist/safe-js/chunks/{chunk-LUBKSEVF.js → chunk-2H5CQNFL.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-6Y27XODE.js";
+} from "./chunk-MT4D4J5E.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-LUBKSEVF.js.map
+//# sourceMappingURL=chunk-2H5CQNFL.js.map

package/dist/safe-js/chunks/{chunk-6Y27XODE.js → chunk-MT4D4J5E.js}

@@ -359,7 +359,7 @@ var Budget = class {
     this.retainedDataSize -= usage;
     this.currentDataSize -= usage;
   }
-  reconcileCompileData(usage, included, transferred = included, retainedOwner, complete = false) {
+  reconcileCompileData(usage, included, transferred = included, retainedOwner, complete2 = false) {
     let includedUsage = 0;
     let transferredUsage = 0;
     let discardedUsage = 0;
@@ -371,7 +371,7 @@ var Budget = class {
       if (charge2 > 0 && transferred.has(ticket) && (this.provisionalScopes === 0 || retainedOwner !== void 0)) {
         releasing.push(ticket);
         transferredUsage += charge2;
-      } else if (charge2 > 0 && complete && transferred.has(ticket)) {
+      } else if (charge2 > 0 && complete2 && transferred.has(ticket)) {
         retained.add(ticket);
       }
     }
@@ -8549,6 +8549,9 @@ function nextStringIterator(value, budget) {
 // packages/safe-js/src/interp/iterator-wrapper.ts
 var iteratorWrapperStates = /* @__PURE__ */ new WeakMap();
 
+// packages/safe-js/src/interp/iterator-helper.ts
+var iteratorHelperStates = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/interp/raw-json.ts
 var rawJsonValues = /* @__PURE__ */ new WeakSet();
 function createRawJson(text) {
@@ -9463,7 +9466,7 @@ function awaitSandboxValue(value, signal, budget, context) {
     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) => {
+      const complete2 = (state, result) => {
         detach?.();
         try {
           consumeSettledHostCall(value2);
@@ -9474,8 +9477,8 @@ function awaitSandboxValue(value, signal, budget, context) {
         }
       };
       outcome.then(
-        (result) => complete("fulfilled", result),
-        (reason) => complete("rejected", reason)
+        (result) => complete2("fulfilled", result),
+        (reason) => complete2("rejected", reason)
       );
     });
     return value2.synchronousPrefix !== void 0 || signal !== void 0 && cancelableOutcomes.get(value2)?.has(signal) ? resolved : awaitWithSignal(resolved, signal);
@@ -9510,13 +9513,13 @@ function awaitWithSignal(promise, signal) {
       listenerActive = false;
       signal.removeEventListener("abort", onAbort);
     };
-    const settle = (complete) => {
+    const settle = (complete2) => {
       if (settled) {
         return;
       }
       settled = true;
       cleanup();
-      complete();
+      complete2();
     };
     signal.addEventListener("abort", onAbort, { once: true });
     Promise.resolve(promise).then(
@@ -21475,7 +21478,7 @@ async function settleIterable(iterable, method, budget, constructor, context) {
   const prototype = getPromisePrototype(budget);
   const values = [];
   let remaining = 1;
-  const complete = async () => {
+  const complete2 = async () => {
     if (remaining !== 0 || method === "race") return;
     if (method === "any") {
       const error = createSubsetErrorValue(
@@ -21547,7 +21550,7 @@ async function settleIterable(iterable, method, budget, constructor, context) {
                 called = true;
                 values[entryIndex] = method === "allSettled" ? state === "fulfilled" ? { status: state, value: settlement } : { status: state, reason: settlement } : settlement;
                 remaining--;
-                await complete();
+                await complete2();
                 return void 0;
               }
             });
@@ -21563,7 +21566,7 @@ async function settleIterable(iterable, method, budget, constructor, context) {
         }
       }
       remaining--;
-      await complete();
+      await complete2();
     } finally {
       releaseIterator();
     }
@@ -21665,7 +21668,7 @@ function resolveThenable(value, then, options) {
     let settlement;
     let completed = false;
     let invocationPending = true;
-    const complete = () => {
+    const complete2 = () => {
       if (completed || invocationPending || settlement === void 0) return;
       completed = true;
       try {
@@ -21685,7 +21688,7 @@ function resolveThenable(value, then, options) {
         return;
       }
       settlement = { state, value: settledValue };
-      queueMicrotask(complete);
+      queueMicrotask(complete2);
     };
     callInPromiseJob(
       then,
@@ -21711,7 +21714,7 @@ function resolveThenable(value, then, options) {
       {
         fulfilled: () => {
           invocationPending = false;
-          complete();
+          complete2();
         },
         rejected: (error) => {
           invocationPending = false;
@@ -21721,7 +21724,7 @@ function resolveThenable(value, then, options) {
             return;
           }
           recordSettlement("rejected", error);
-          complete();
+          complete2();
         }
       },
       options.context
@@ -22033,6 +22036,21 @@ function serializeCollectionProperties(value, encode, dataOnly = false) {
 
 // packages/safe-js/src/snapshot/guest-heap.ts
 function captureGuestHeapNode(value, encode) {
+  const helper = iteratorHelperStates.get(value);
+  if (helper !== void 0) {
+    if (helper.status === "executing") throw new TypeError("Cannot snapshot an executing iterator helper.");
+    return {
+      kind: "iterator-helper",
+      method: helper.method,
+      status: helper.status,
+      ...helper.outer === void 0 ? {} : { outer: { iterator: encode(helper.outer.iterator), next: encode(helper.outer.next) } },
+      ...helper.inner === void 0 ? {} : { inner: { iterator: encode(helper.inner.iterator), next: encode(helper.inner.next) } },
+      callback: encode(helper.callback),
+      remaining: helper.remaining === Infinity ? "Infinity" : helper.remaining,
+      index: helper.index,
+      state: captureObjectState(value, encode)
+    };
+  }
   const wrapper = iteratorWrapperStates.get(value);
   if (wrapper !== void 0)
     return { kind: "iterator-wrapper", iterator: encode(wrapper.iterator), next: encode(wrapper.next), state: captureObjectState(value, encode) };
@@ -24213,13 +24231,13 @@ function wrapHostPromiseWithSignal(promise, signal) {
     const cleanup = () => {
       signal.removeEventListener("abort", onAbort);
     };
-    const settle = (complete) => {
+    const settle = (complete2) => {
       if (settled) {
         return;
       }
       settled = true;
       cleanup();
-      complete();
+      complete2();
     };
     const onAbort = () => {
       settle(() => reject(readAbortReason2(signal)));
@@ -26506,6 +26524,183 @@ function installIteratorConsumers(prototype, budget) {
   }
 }
 
+// packages/safe-js/src/interp/globals/iterator-lazy.ts
+function installLazyIteratorHelpers(common, budget) {
+  const prototype = /* @__PURE__ */ Object.create(null);
+  setSandboxPrototype(prototype, common);
+  Object.defineProperty(prototype, Symbol.toStringTag, { value: "Iterator Helper", configurable: true });
+  for (const operation of ["next", "return"]) {
+    Object.defineProperty(prototype, operation, { writable: true, configurable: true, value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: operation,
+      length: 0,
+      call: async (_args, context) => {
+        const receiver = context?.thisValue;
+        const state = receiver !== null && typeof receiver === "object" ? iteratorHelperStates.get(receiver) : void 0;
+        if (state === void 0) throw new TypeError("Iterator helper method requires a branded receiver.");
+        if (state.status === "executing") throw new TypeError("Iterator helper is already executing.");
+        if (state.status === "done") return { value: void 0, done: true };
+        state.status = "executing";
+        try {
+          const outer = state.outer;
+          if (operation === "return") {
+            if (state.inner !== void 0) {
+              try {
+                await closeIterator(adapter(state.inner, context));
+              } catch (error) {
+                if (!isFatalSandboxError(error)) await closeIterator(adapter(outer, context), true);
+                throw error;
+              }
+            }
+            await closeIterator(adapter(outer, context));
+            complete(state);
+            return { value: void 0, done: true };
+          }
+          while (true) {
+            budget.visitNode();
+            if (state.inner !== void 0) {
+              let innerResult;
+              try {
+                innerResult = await step(state.inner, context);
+              } catch (error) {
+                if (!isFatalSandboxError(error)) await closeIterator(adapter(outer, context), true);
+                throw error;
+              }
+              if (!innerResult.done) {
+                state.status = "yield";
+                return innerResult;
+              }
+              state.inner = void 0;
+            }
+            if (state.method === "take" && state.remaining === 0) {
+              await closeIterator(adapter(outer, context));
+              complete(state);
+              return { value: void 0, done: true };
+            }
+            const skipping = state.method === "drop" && state.remaining > 0;
+            if ((state.method === "take" || skipping) && state.remaining !== Infinity) state.remaining--;
+            const result = await step(outer, context, skipping);
+            if (result.done) {
+              complete(state);
+              return result;
+            }
+            if (skipping) continue;
+            if (state.method === "take" || state.method === "drop") {
+              state.status = "yield";
+              return result;
+            }
+            let mapped;
+            const release = retainValues(budget, () => [result.value, mapped]);
+            try {
+              try {
+                mapped = await invokeBuiltinClosure(state.callback, [result.value, state.index++], budget, context, void 0);
+                if (state.method === "flatMap") {
+                  if (mapped === null || typeof mapped !== "object") throw new TypeError("flatMap callback must return an object.");
+                  const method = await read(mapped, Symbol.iterator, context);
+                  let inner = mapped;
+                  if (method !== void 0 && method !== null) {
+                    if (!isSandboxClosure(method)) throw new TypeError("Symbol.iterator must be callable.");
+                    const value = await invokeBuiltinClosure(method, [], budget, context, mapped);
+                    if (value === null || typeof value !== "object") throw new TypeError("Inner iterator must be an object.");
+                    inner = value;
+                  }
+                  state.inner = { iterator: inner, next: await read(inner, "next", context) };
+                }
+              } catch (error) {
+                if (!isFatalSandboxError(error)) await closeIterator(adapter(outer, context), true);
+                throw error;
+              }
+              if (state.method === "map") {
+                state.status = "yield";
+                return { value: mapped, done: false };
+              }
+              if (state.method === "filter" && mapped) {
+                state.status = "yield";
+                return result;
+              }
+            } finally {
+              release();
+            }
+          }
+        } catch (error) {
+          complete(state);
+          throw error;
+        }
+      }
+    }) });
+  }
+  for (const method of ["map", "filter", "take", "drop", "flatMap"]) {
+    Object.defineProperty(common, method, { writable: true, configurable: true, value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: method,
+      length: 1,
+      call: async ([argument], context) => {
+        const receiver = context?.thisValue;
+        if (receiver === null || typeof receiver !== "object") throw new TypeError("Iterator helper requires an object.");
+        const outer = { iterator: receiver, next: void 0 };
+        let remaining = 0;
+        try {
+          if (method === "take" || method === "drop") {
+            const number = await sandboxNumber(argument, budget, context);
+            if (Number.isNaN(number)) throw new RangeError("Iterator limit must not be NaN.");
+            remaining = Math.trunc(number);
+            if (remaining < 0) throw new RangeError("Iterator limit must not be negative.");
+          } else if (!isSandboxClosure(argument)) throw new TypeError("Iterator callback must be callable.");
+        } catch (error) {
+          if (!isFatalSandboxError(error)) await closeIterator(adapter(outer, context), true);
+          throw error;
+        }
+        outer.next = await read(receiver, "next", context);
+        const helper = /* @__PURE__ */ Object.create(null);
+        iteratorHelperStates.set(helper, { method, status: "start", outer, callback: method === "take" || method === "drop" ? void 0 : argument, remaining, index: 0 });
+        setSandboxPrototype(helper, prototype, budget);
+        createDataCheckpoint(budget, context)(helper, 0, true);
+        return helper;
+      }
+    }) });
+  }
+  registerBuiltinIdentities(budget, { "%IteratorPrototype%": common, "%IteratorHelperPrototype%": prototype });
+  registerIntrinsicObject(budget, prototype);
+  registerIntrinsicObject(budget, common);
+  function adapter(record4, context) {
+    return { asynchronous: true, next: async () => {
+      if (!isSandboxClosure(record4.next)) throw new TypeError("Iterator next must be callable.");
+      const result = await invokeBuiltinClosure(record4.next, [], budget, context, record4.iterator);
+      if (result === null || typeof result !== "object") throw new TypeError("Iterator result must be an object.");
+      return result;
+    }, getOperation: async () => {
+      const method = await read(record4.iterator, "return", context);
+      if (method === void 0 || method === null) return void 0;
+      if (!isSandboxClosure(method)) throw new TypeError("Iterator return must be callable.");
+      return async () => await invokeBuiltinClosure(method, [], budget, context, record4.iterator);
+    } };
+  }
+  async function step(record4, context, skipValue = false) {
+    let result;
+    const release = retainValues(budget, () => [result]);
+    try {
+      result = await adapter(record4, context).next();
+      if (await read(result, "done", context)) return { value: void 0, done: true };
+      return { value: skipValue ? void 0 : await read(result, "value", context), done: false };
+    } finally {
+      release();
+    }
+  }
+  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);
+  }
+}
+function complete(state) {
+  state.status = "done";
+  state.outer = void 0;
+  state.inner = void 0;
+  state.callback = void 0;
+}
+
 // packages/safe-js/src/interp/globals/iterator.ts
 function createIteratorGlobal(budget) {
   const prototype = resolveIntrinsicIdentity(budget, '["%IteratorPrototype%"]');
@@ -26545,6 +26740,7 @@ function createIteratorGlobal(budget) {
   registerIntrinsicFunction(budget, setter);
   installIteratorFrom(constructor, budget);
   installIteratorConsumers(prototype, budget);
+  installLazyIteratorHelpers(prototype, budget);
   registerIntrinsicFunction(budget, constructor);
   registerIntrinsicObject(budget, prototype);
   return constructor;
@@ -27250,7 +27446,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["intrinsic", "bound-function", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "array-iterator", "string-iterator", "iterator-wrapper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
+  if (!["intrinsic", "bound-function", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "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"]);
@@ -27304,7 +27500,29 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     });
     return false;
   }
-  if (node.kind === "iterator-wrapper") {
+  if (node.kind === "iterator-helper") {
+    fields(node, ["kind", "method", "status", "callback", "remaining", "index", "state"], ["outer", "inner"]);
+    if (!["map", "filter", "take", "drop", "flatMap"].includes(String(node.method)) || !["start", "yield", "done"].includes(String(node.status))) throw new TypeError("Invalid iterator helper mode.");
+    integer(node.index);
+    if (node.remaining !== "Infinity" && (typeof node.remaining !== "number" || !Number.isInteger(node.remaining) || node.remaining < 0))
+      throw new TypeError("Invalid iterator helper limit.");
+    for (const key of ["outer", "inner"]) {
+      if (!Object.hasOwn(node, key)) continue;
+      const cursor = record3(node[key]);
+      fields(cursor, ["iterator", "next"]);
+      const target = reference(cursor.iterator);
+      if (target.kind === "symbol" || target.kind === "scope-frame") throw new TypeError("Invalid helper iterator.");
+    }
+    if (node.status === "done" === Object.hasOwn(node, "outer") || Object.hasOwn(node, "inner") && (node.method !== "flatMap" || node.status !== "yield"))
+      throw new TypeError("Invalid iterator helper cursor state.");
+    if (node.status === "done" || node.method === "take" || node.method === "drop") {
+      if (!absent(node.callback)) throw new TypeError("Unexpected iterator helper callback.");
+    } else {
+      if (absent(node.callback)) throw new TypeError("Missing iterator helper callback.");
+      callable(node.callback);
+    }
+    state(node.state);
+  } else if (node.kind === "iterator-wrapper") {
     fields(node, ["kind", "iterator", "next", "state"]);
     const iterator = reference(node.iterator);
     if (iterator.kind === "symbol" || iterator.kind === "scope-frame") throw new TypeError("Invalid wrapped iterator.");
@@ -29152,6 +29370,8 @@ function* cloneStructuredGraph(value, state, budget, depth = 0) {
   if (typeof value === "symbol" || isSandboxModuleNamespace(value) || isSandboxClosure(value) || isSandboxPromise(value) || isSandboxGenerator(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxArrayIterator(value) || isSandboxStringIterator(value) || isSandboxArguments(value))
     throw new DOMException("Value cannot be structured cloned.", "DataCloneError");
   if (typeof value !== "object" || value === null) return allocateProducedSandboxValue(value, budget);
+  if (iteratorHelperStates.has(value) || iteratorWrapperStates.has(value))
+    throw new DOMException("Iterator objects cannot be structured cloned.", "DataCloneError");
   if (isLiveCapability(value)) throw new DOMException("Capabilities cannot be structured cloned.", "DataCloneError");
   const existing = state.seen.get(value);
   if (existing !== void 0) return existing;
@@ -29279,6 +29499,16 @@ function measureSandboxData(values, options = {}) {
       visit(wrapperState.iterator, depth + 1);
       visit(wrapperState.next, depth + 1);
     }
+    const helperState = iteratorHelperStates.get(value);
+    if (helperState !== void 0) {
+      for (const record4 of [helperState.outer, helperState.inner]) {
+        if (record4 !== void 0) {
+          visit(record4.iterator, depth + 1);
+          visit(record4.next, depth + 1);
+        }
+      }
+      visit(helperState.callback, depth + 1);
+    }
     if (isSandboxDate(value)) usage += 8;
     if (isGuestHostObject(value)) {
       usage += measureHostObjectData(value);
@@ -30605,7 +30835,7 @@ var HostCallJournal = class {
     return waiter.promise;
   }
   trackCallbackCompletion(record4, callbacks) {
-    const complete = () => {
+    const complete2 = () => {
       this.completedCallbackOwners.add(record4.id);
       for (const [id, waiter] of this.capabilityWaiters) {
         if (!id.startsWith(`${record4.id}/function/`)) continue;
@@ -30613,8 +30843,8 @@ var HostCallJournal = class {
         this.capabilityWaiters.delete(id);
       }
     };
-    if (callbacks.length === 0) complete();
-    else void Promise.allSettled(callbacks).then(complete);
+    if (callbacks.length === 0) complete2();
+    else void Promise.allSettled(callbacks).then(complete2);
   }
   recordCallback(record4, id, args, step) {
     const retainedSize = this.retainedSize + 1 + measureSandboxData([args], { ignoreClosures: true });
@@ -42805,13 +43035,13 @@ var RealmState = class {
       );
   };
   startCallback = (callback, options = {}) => {
-    let complete;
+    let complete2;
     let fail2;
     const synchronous = new Promise((resolve, reject) => {
-      complete = resolve;
+      complete2 = resolve;
       fail2 = reject;
     });
-    const result = this.executeCallback(callback, options, complete);
+    const result = this.executeCallback(callback, options, complete2);
     void result.catch(fail2);
     void synchronous.catch(() => void 0);
     return Object.freeze({ synchronous, result });
@@ -44408,4 +44638,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-6Y27XODE.js.map
+//# sourceMappingURL=chunk-MT4D4J5E.js.map