@poe-platform/safe-js 0.1.368 → 0.1.370

package/dist/safe-js/chunks/{chunk-YZVG2IAP.js → chunk-CEICOOQA.js}

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

package/dist/safe-js/chunks/{chunk-MIIX63EV.js → chunk-JJH7D3EH.js}

@@ -7360,6 +7360,55 @@ function copyCollectionProperties(source, target, encode) {
   if (!Object.isExtensible(properties)) Object.preventExtensions(target);
 }
 
+// packages/safe-js/src/interp/resources.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var runResources = new AsyncLocalStorage();
+function retainValues(budget, values) {
+  const retained = {};
+  budget.setRetainedValues(retained, values);
+  const pending = runResources.getStore()?.referenceReleases;
+  const release = () => {
+    budget.setRetainedValues(retained, void 0);
+    pending?.delete(release);
+  };
+  pending?.add(release);
+  return release;
+}
+async function withRunResources(signal, execute) {
+  const controller = new AbortController();
+  const cancel = () => controller.abort(signal?.reason);
+  const cleanups = /* @__PURE__ */ new Set();
+  const resources = {
+    signal: controller.signal,
+    referenceReleases: /* @__PURE__ */ new Set(),
+    add(close) {
+      cleanups.add(close);
+    }
+  };
+  signal?.addEventListener("abort", cancel, { once: true });
+  if (signal?.aborted) cancel();
+  let result;
+  let failure;
+  let errors = [];
+  try {
+    result = await runResources.run(resources, execute);
+  } catch (error) {
+    failure = { reason: error };
+  } finally {
+    signal?.removeEventListener("abort", cancel);
+    controller.abort(new Error("SafeJS run finished."));
+    for (const release of resources.referenceReleases) release();
+    resources.referenceReleases.clear();
+    const outcomes = await Promise.allSettled(
+      [...cleanups].map((close) => Promise.resolve().then(close))
+    );
+    errors = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
+  }
+  if (failure !== void 0) throw failure.reason;
+  if (errors.length > 0) throw new AggregateError(errors, "SafeJS resource cleanup failed.");
+  return result;
+}
+
 // packages/safe-js/src/interp/collection-brands.ts
 var sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
 var sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
@@ -7654,55 +7703,6 @@ function graphEntries(value) {
 // packages/safe-js/src/interp/generator-prototypes.ts
 var generatorPrototypes = /* @__PURE__ */ new WeakMap();
 
-// packages/safe-js/src/interp/resources.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var runResources = new AsyncLocalStorage();
-function retainValues(budget, values) {
-  const retained = {};
-  budget.setRetainedValues(retained, values);
-  const pending = runResources.getStore()?.referenceReleases;
-  const release = () => {
-    budget.setRetainedValues(retained, void 0);
-    pending?.delete(release);
-  };
-  pending?.add(release);
-  return release;
-}
-async function withRunResources(signal, execute) {
-  const controller = new AbortController();
-  const cancel = () => controller.abort(signal?.reason);
-  const cleanups = /* @__PURE__ */ new Set();
-  const resources = {
-    signal: controller.signal,
-    referenceReleases: /* @__PURE__ */ new Set(),
-    add(close) {
-      cleanups.add(close);
-    }
-  };
-  signal?.addEventListener("abort", cancel, { once: true });
-  if (signal?.aborted) cancel();
-  let result;
-  let failure;
-  let errors = [];
-  try {
-    result = await runResources.run(resources, execute);
-  } catch (error) {
-    failure = { reason: error };
-  } finally {
-    signal?.removeEventListener("abort", cancel);
-    controller.abort(new Error("SafeJS run finished."));
-    for (const release of resources.referenceReleases) release();
-    resources.referenceReleases.clear();
-    const outcomes = await Promise.allSettled(
-      [...cleanups].map((close) => Promise.resolve().then(close))
-    );
-    errors = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
-  }
-  if (failure !== void 0) throw failure.reason;
-  if (errors.length > 0) throw new AggregateError(errors, "SafeJS resource cleanup failed.");
-  return result;
-}
-
 // packages/safe-js/src/interp/host-capabilities.ts
 import { types as types6 } from "node:util";
 var MAX_INDEXED_LENGTH = 65536;
@@ -25557,6 +25557,7 @@ function createRegexGlobals(options) {
 
 // packages/safe-js/src/interp/globals/structured-clone.ts
 var transferBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "transfer")?.value;
+var resizeBuffer2 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize")?.value;
 function createStructuredCloneGlobal(budget) {
   return createSandboxClosure({
     guest: true,
@@ -25627,37 +25628,67 @@ function cloneStructuredValue(value, transfers, budget, context) {
   const buffers = /* @__PURE__ */ new WeakMap();
   let clone;
   const release = retainValues(budget, () => [value, clone, transfers]);
-  try {
-    let transferSize = 0;
-    for (const buffer of transfers) {
-      const length = arrayBufferLength(buffer);
-      budget.allocateArrayLength(arrayBufferOptions(buffer)?.maxByteLength ?? length);
-      transferSize += length + 1;
-      if (arrayBufferDetached(buffer)) buffers.set(buffer, new ArrayBuffer(0));
-    }
-    budget.provisionDataUsage(transferSize)();
-    clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true, structuredClone: true, float32Buffers: buffers });
-    assertSandboxGraphDepth(clone);
-    assertStructuredCloneable(clone, /* @__PURE__ */ new WeakSet());
-    allocateProducedSandboxValue(clone, budget);
-    if (compilation !== parent) reconcileCompiledValues(budget, [clone], compilation);
-    if (transfers.length > 0) {
-      createDataCheckpoint(budget, context)(clone, 0, true);
-      budget.visitNode(transferSize + transfers.length);
-      budget.provisionDataUsage(transferBuffer === void 0 ? transferSize : transfers.length)();
+  function* execute() {
+    try {
+      let transferSize = 0;
       for (const buffer of transfers) {
-        if (arrayBufferDetached(buffer)) throw new DOMException("Cannot transfer a detached ArrayBuffer.", "DataCloneError");
-        if (transferBuffer !== void 0) Reflect.apply(transferBuffer, buffer, [0]);
-        else structuredClone(buffer, { transfer: [buffer] });
-        if (!arrayBufferDetached(buffer)) throw new DOMException("ArrayBuffer cannot be transferred.", "DataCloneError");
-      }
+        const length = arrayBufferLength(buffer);
+        budget.allocateArrayLength(arrayBufferOptions(buffer)?.maxByteLength ?? length);
+        transferSize += length + 1;
+      }
+      budget.provisionDataUsage(transferSize)();
+      for (const buffer of transfers) buffers.set(buffer, Reflect.construct(ArrayBuffer, [arrayBufferLength(buffer), arrayBufferOptions(buffer)]));
+      const state = { seen: /* @__PURE__ */ new WeakMap(), compilation, resetRegexLastIndex: true, structuredClone: true, float32Buffers: buffers };
+      clone = context?.invokeClosure === void 0 ? cloneSandboxValue(value, state) : yield* cloneStructuredGraph(value, state, budget);
+      transferSize = 0;
+      for (const buffer of transfers) {
+        if (arrayBufferDetached(buffer)) continue;
+        const length = arrayBufferLength(buffer);
+        transferSize += length + 1;
+        budget.allocateArrayLength(arrayBufferOptions(buffer)?.maxByteLength ?? length);
+        const destination = buffers.get(buffer);
+        budget.provisionDataUsage(Math.max(0, length - arrayBufferLength(destination)))();
+        if (arrayBufferLength(destination) !== length) Reflect.apply(resizeBuffer2, destination, [length]);
+        new Uint8Array(destination).set(new Uint8Array(buffer));
+      }
+      assertSandboxGraphDepth(clone);
+      assertStructuredCloneable(clone, /* @__PURE__ */ new WeakSet());
+      allocateProducedSandboxValue(clone, budget);
+      if (compilation !== parent) reconcileCompiledValues(budget, [clone], compilation);
+      if (transfers.length > 0) {
+        createDataCheckpoint(budget, context)(clone, 0, true);
+        budget.visitNode(transferSize + transfers.length);
+        budget.provisionDataUsage(transferBuffer === void 0 ? transferSize : transfers.length)();
+        for (const buffer of transfers) {
+          if (arrayBufferDetached(buffer)) throw new DOMException("Cannot transfer a detached ArrayBuffer.", "DataCloneError");
+          if (transferBuffer !== void 0) Reflect.apply(transferBuffer, buffer, [0]);
+          else structuredClone(buffer, { transfer: [buffer] });
+          if (!arrayBufferDetached(buffer)) throw new DOMException("ArrayBuffer cannot be transferred.", "DataCloneError");
+        }
+      }
+      return clone;
+    } finally {
+      release();
+      if (compilation !== parent) compilation.dispose();
+      operation.release();
     }
-    return clone;
-  } finally {
-    release();
-    if (compilation !== parent) compilation.dispose();
-    operation.release();
   }
+  const iterator = execute();
+  const first = iterator.next();
+  if (first.done) return first.value;
+  return (async () => {
+    let step = first;
+    try {
+      while (!step.done) {
+        const { descriptor, receiver } = step.value;
+        createDataCheckpoint(budget, context)(receiver, 0, true);
+        step = iterator.next(await readPropertyDescriptor(descriptor, receiver, context));
+      }
+      return step.value;
+    } finally {
+      iterator.return(void 0);
+    }
+  })();
 }
 function assertStructuredCloneable(value, seen) {
   if (typeof value === "symbol") throw new DOMException("Cannot clone a symbol value.", "DataCloneError");
@@ -26034,7 +26065,7 @@ function createBigIntGlobal(budget) {
 }
 
 // packages/safe-js/src/interp/globals/array-buffer.ts
-var resizeBuffer2 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize")?.value;
+var resizeBuffer3 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize")?.value;
 var transferBuffer2 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "transfer")?.value;
 function createArrayBufferGlobal(budget) {
   const prototype = /* @__PURE__ */ Object.create(null);
@@ -26076,7 +26107,7 @@ function createArrayBufferGlobal(budget) {
         }
         const target = context?.newTarget ?? constructor;
         selected = await bridge.getProperty(target, "prototype");
-        if (maxByteLength !== void 0 && resizeBuffer2 === void 0)
+        if (maxByteLength !== void 0 && resizeBuffer3 === void 0)
           throw new TypeError("Resizable ArrayBuffer requires host runtime support.");
         budget.allocateArrayLength(maxByteLength ?? length);
         budget.provisionDataUsage(length + 1)();
@@ -26234,7 +26265,7 @@ function createArrayBufferGlobal(budget) {
       length: 1,
       call: async (args, context) => {
         const receiver = context?.thisValue;
-        if (resizeBuffer2 === void 0 || !isSandboxArrayBuffer(receiver) || arrayBufferOptions(receiver) === void 0)
+        if (resizeBuffer3 === void 0 || !isSandboxArrayBuffer(receiver) || arrayBufferOptions(receiver) === void 0)
           throw new TypeError("ArrayBuffer resize requires a resizable buffer receiver.");
         const release = retainValues(budget, () => [receiver, ...args]);
         try {
@@ -26244,7 +26275,7 @@ function createArrayBufferGlobal(budget) {
             throw new RangeError("Invalid ArrayBuffer resize length.");
           budget.allocateArrayLength(length);
           budget.provisionDataUsage(Math.max(length - arrayBufferLength(receiver), 0))();
-          Reflect.apply(resizeBuffer2, receiver, [length]);
+          Reflect.apply(resizeBuffer3, receiver, [length]);
           return void 0;
         } finally {
           release();
@@ -28334,6 +28365,66 @@ function allocateProducedSandboxValue(value, budget) {
   allocateSandboxValue2(value, budget, /* @__PURE__ */ new WeakSet());
   return value;
 }
+function* cloneStructuredGraph(value, state, budget, depth = 0) {
+  assertSandboxDataDepth(depth);
+  budget.visitNode();
+  if (typeof value === "symbol" || isSandboxClosure(value) || isSandboxPromise(value) || isSandboxGenerator(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxArrayIterator(value) || isSandboxArguments(value))
+    throw new DOMException("Value cannot be structured cloned.", "DataCloneError");
+  if (typeof value !== "object" || value === null) return allocateProducedSandboxValue(value, budget);
+  if (isLiveCapability(value)) throw new DOMException("Capabilities cannot be structured cloned.", "DataCloneError");
+  const existing = state.seen.get(value);
+  if (existing !== void 0) return existing;
+  const map = isSandboxMap(value);
+  const set = isSandboxSet(value);
+  const array2 = isPlainArray(value);
+  const plain = isPlainObject4(value) && !isSandboxRegex(value) && !isRawJson(value) && nativeBoxedValue(value) === void 0;
+  if (!map && !set && !array2 && !plain) {
+    const copy2 = copyToSandbox(value, state, "<root>", true, depth);
+    allocateProducedSandboxValue(copy2, budget);
+    return copy2;
+  }
+  if (array2) budget.allocateArrayLength(value.length);
+  budget.provisionDataUsage(1)();
+  const copy = map ? createSandboxMap() : set ? createSandboxSet() : array2 ? new Array(value.length) : createPlainObject(Object.getPrototypeOf(value) === null);
+  state.seen.set(value, copy);
+  const errorType = sandboxErrorTypes.get(value);
+  if (errorType !== void 0) sandboxErrorTypes.set(copy, errorType);
+  let pending;
+  let current;
+  const release = retainValues(budget, () => [value, copy, pending, current]);
+  try {
+    if (map && isSandboxMap(copy)) {
+      budget.allocateArrayLength(value.entries.size);
+      budget.provisionDataUsage(value.entries.size * 3 + 1)();
+      const entries = [...value.entries];
+      pending = entries;
+      for (const [key, entry] of entries) {
+        current = yield* cloneStructuredGraph(key, state, budget, depth + 1);
+        copy.entries.set(current, yield* cloneStructuredGraph(entry, state, budget, depth + 1));
+      }
+    } else if (set && isSandboxSet(copy)) {
+      budget.allocateArrayLength(value.values.size);
+      budget.provisionDataUsage(value.values.size + 1)();
+      const entries = [...value.values];
+      pending = entries;
+      for (const entry of entries) copy.values.add(yield* cloneStructuredGraph(entry, state, budget, depth + 1));
+    } else {
+      const keys = Object.keys(value);
+      budget.allocateArrayLength(keys.length);
+      budget.provisionDataUsage(keys.length + 1)();
+      pending = keys;
+      for (const key of keys) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === void 0) continue;
+        current = "value" in descriptor ? descriptor.value : yield { descriptor, receiver: value };
+        defineOwnDataProperty(copy, key, yield* cloneStructuredGraph(current, state, budget, depth + 1));
+      }
+    }
+    return copy;
+  } finally {
+    release();
+  }
+}
 function measureSandboxData(values, options = {}) {
   const seen = /* @__PURE__ */ new WeakSet();
   const seenSymbols = /* @__PURE__ */ new Set();
@@ -28598,6 +28689,8 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
   if (isSandboxPrimitive(value)) {
     return value;
   }
+  if (state.structuredClone && nodeTypes.isSymbolObject(value))
+    throw new DOMException("Cannot clone a boxed symbol.", "DataCloneError");
   if (isLiveCapability(value)) throw new TypeError("Live capabilities require their owning realm bridge.");
   if (isRawJson(value)) {
     const existing = state.seen.get(value);
@@ -43503,4 +43596,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-MIIX63EV.js.map
+//# sourceMappingURL=chunk-JJH7D3EH.js.map