@poe-platform/safe-js 0.1.351 → 0.1.353

package/dist/safe-js/chunks/{chunk-Z7WNQACZ.js → chunk-BWBBXXBE.js}

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

package/dist/safe-js/chunks/{chunk-AS6HS2LE.js → chunk-LZ2NZ2PE.js}

@@ -6848,6 +6848,7 @@ import { types as types2 } from "node:util";
 var readLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
 var readResizable = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resizable")?.get;
 var readMaxLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "maxByteLength")?.get;
+var readDetached = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "detached")?.get;
 var arrayBufferPrototypes = /* @__PURE__ */ new WeakMap();
 function isSandboxArrayBuffer(value) {
   return types2.isArrayBuffer(value) && Object.getPrototypeOf(value) === ArrayBuffer.prototype;
@@ -6855,6 +6856,16 @@ function isSandboxArrayBuffer(value) {
 function arrayBufferLength(value) {
   return Reflect.apply(readLength, value, []);
 }
+function arrayBufferDetached(value) {
+  if (readDetached !== void 0) return Reflect.apply(readDetached, value, []);
+  try {
+    new Uint8Array(value, 0, 0);
+    return false;
+  } catch (error) {
+    if (error instanceof TypeError) return true;
+    throw error;
+  }
+}
 function arrayBufferOptions(value) {
   return readResizable !== void 0 && Reflect.apply(readResizable, value, []) ? { maxByteLength: Reflect.apply(readMaxLength, value, []) } : void 0;
 }
@@ -25458,7 +25469,7 @@ function createBigIntGlobal(budget) {
 
 // packages/safe-js/src/interp/globals/array-buffer.ts
 var resizeBuffer2 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize")?.value;
-var readDetached = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "detached")?.get;
+var transferBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "transfer")?.value;
 function createArrayBufferGlobal(budget) {
   const prototype = /* @__PURE__ */ Object.create(null);
   const constructor = createSandboxClosure({
@@ -25601,6 +25612,52 @@ function createArrayBufferGlobal(budget) {
       }
     })
   });
+  for (const key of ["transfer", "transferToFixedLength"]) Object.defineProperty(prototype, key, {
+    writable: true,
+    configurable: true,
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: key,
+      length: 0,
+      call: async (args, context) => {
+        const receiver = context?.thisValue;
+        if (!isSandboxArrayBuffer(receiver)) throw new TypeError("ArrayBuffer transfer requires a buffer receiver.");
+        let result;
+        const release = retainValues(budget, () => [receiver, result, ...args]);
+        const checkData = createDataCheckpoint(budget, context);
+        try {
+          const number = args[0] === void 0 ? arrayBufferLength(receiver) : await sandboxNumber(args[0], budget, context);
+          const length = Number.isNaN(number) ? 0 : Math.trunc(number);
+          if (!Number.isSafeInteger(length) || length < 0) throw new RangeError("Invalid ArrayBuffer transfer length.");
+          if (arrayBufferDetached(receiver)) throw new TypeError("Cannot transfer a detached ArrayBuffer.");
+          const options = key === "transfer" ? arrayBufferOptions(receiver) : void 0;
+          if (options !== void 0 && length > options.maxByteLength) throw new RangeError("Transfer length exceeds ArrayBuffer capacity.");
+          budget.allocateArrayLength(options?.maxByteLength ?? length);
+          checkData(receiver, 0, true);
+          budget.provisionDataUsage(length + 1)();
+          result = Reflect.construct(ArrayBuffer, [length, options]);
+          setSandboxPrototype(result, prototype, budget);
+          checkData(result, 0, true);
+          const count = Math.min(length, arrayBufferLength(receiver));
+          budget.visitNode(count);
+          new Uint8Array(result, 0, count).set(new Uint8Array(receiver, 0, count));
+          if (transferBuffer !== void 0) {
+            budget.provisionDataUsage(1)();
+            Reflect.apply(transferBuffer, receiver, [0]);
+          } else {
+            budget.provisionDataUsage(arrayBufferLength(receiver) + 1)();
+            budget.visitNode(arrayBufferLength(receiver));
+            structuredClone(receiver, { transfer: [receiver] });
+            if (!arrayBufferDetached(receiver)) throw new TypeError("ArrayBuffer cannot be detached.");
+          }
+          return result;
+        } finally {
+          release();
+        }
+      }
+    })
+  });
   Object.defineProperty(prototype, "resize", {
     writable: true,
     configurable: true,
@@ -25638,16 +25695,7 @@ function createArrayBufferGlobal(budget) {
       call: (_args, context) => {
         if (!isSandboxArrayBuffer(context?.thisValue)) throw new TypeError(`ArrayBuffer ${key} requires a buffer receiver.`);
         if (key === "byteLength") return arrayBufferLength(context.thisValue);
-        if (key === "detached") {
-          if (readDetached !== void 0) return Reflect.apply(readDetached, context.thisValue, []);
-          try {
-            new Uint8Array(context.thisValue, 0, 0);
-            return false;
-          } catch (error) {
-            if (error instanceof TypeError) return true;
-            throw error;
-          }
-        }
+        if (key === "detached") return arrayBufferDetached(context.thisValue);
         const options = arrayBufferOptions(context.thisValue);
         return key === "resizable" ? options !== void 0 : options?.maxByteLength ?? arrayBufferLength(context.thisValue);
       }
@@ -42688,4 +42736,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-AS6HS2LE.js.map
+//# sourceMappingURL=chunk-LZ2NZ2PE.js.map