@poe-platform/safe-js 0.1.319 → 0.1.320

package/dist/safe-js/chunks/{chunk-ZXUROMXW.js → chunk-3KICEWDS.js}

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

package/dist/safe-js/chunks/{chunk-CYVI4ZUK.js → chunk-J5UIUYUC.js}

@@ -25123,6 +25123,7 @@ function createBigIntGlobal(budget) {
 
 // packages/safe-js/src/interp/globals/array-buffer.ts
 var resizeBuffer2 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize").value;
+var detachedBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "detached").get;
 function createArrayBufferGlobal(budget) {
   const prototype = /* @__PURE__ */ Object.create(null);
   const constructor = createSandboxClosure({
@@ -25190,6 +25191,78 @@ function createArrayBufferGlobal(budget) {
     [Symbol.toStringTag]: { value: "ArrayBuffer", configurable: true }
   });
   const getters = [];
+  const species = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "get [Symbol.species]",
+    length: 0,
+    call: (_args, context) => context?.thisValue
+  });
+  getters.push(species);
+  Object.defineProperty(materializeFunctionProperties(constructor), Symbol.species, {
+    get: accessorAdapter(species, "get"),
+    configurable: true
+  });
+  Object.defineProperty(prototype, "slice", {
+    writable: true,
+    configurable: true,
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "slice",
+      length: 2,
+      call: async (args, context) => {
+        const receiver = context?.thisValue;
+        if (!isSandboxArrayBuffer(receiver)) throw new TypeError("ArrayBuffer slice requires a buffer receiver.");
+        if (Reflect.apply(detachedBuffer, receiver, [])) throw new TypeError("Cannot slice a detached ArrayBuffer.");
+        const length = arrayBufferLength(receiver);
+        let candidate;
+        let result;
+        const bridge = {
+          ...context,
+          stack: context?.stack ?? [],
+          thisValue: receiver,
+          getProperty: context?.getProperty ?? ((value, key) => {
+            const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+            return descriptor === void 0 ? getSandboxDataProperty(value, key, budget) : readPropertyDescriptor(descriptor, value, bridge);
+          }),
+          invokeClosure: context?.invokeClosure ?? ((callee, values, thisValue, construct) => invokeBuiltinClosure(callee, values, budget, context, thisValue, construct))
+        };
+        const release = retainValues(budget, () => [receiver, candidate, result, ...args]);
+        const clamp = (number) => {
+          const integer2 = Number.isNaN(number) ? 0 : Math.trunc(number);
+          return integer2 < 0 ? Math.max(length + integer2, 0) : Math.min(integer2, length);
+        };
+        try {
+          const start = clamp(await sandboxNumber(args[0], budget, bridge));
+          const end = args[1] === void 0 ? length : clamp(await sandboxNumber(args[1], budget, bridge));
+          const size = Math.max(end - start, 0);
+          candidate = await bridge.getProperty(receiver, "constructor");
+          if (candidate !== void 0) {
+            if (candidate === null || typeof candidate !== "object")
+              throw new TypeError("ArrayBuffer constructor must be an object.");
+            candidate = await bridge.getProperty(candidate, Symbol.species);
+            if (candidate !== void 0 && candidate !== null && (!isSandboxClosure(candidate) || candidate.construct === void 0))
+              throw new TypeError("ArrayBuffer species must be a constructor.");
+          }
+          if (candidate === void 0 || candidate === null || candidate === constructor) {
+            budget.allocateArrayLength(size);
+            budget.provisionDataUsage(size + 1)();
+            result = new ArrayBuffer(size);
+            setSandboxPrototype(result, prototype, budget);
+          } else result = await invokeBuiltinClosure(candidate, [size], budget, bridge, void 0, true);
+          if (!isSandboxArrayBuffer(result) || Reflect.apply(detachedBuffer, result, []) || result === receiver || arrayBufferLength(result) < size)
+            throw new TypeError("ArrayBuffer species must return distinct sufficient buffer storage.");
+          if (Reflect.apply(detachedBuffer, receiver, [])) throw new TypeError("Cannot slice a detached ArrayBuffer.");
+          const count = Math.min(size, Math.max(arrayBufferLength(receiver) - start, 0));
+          if (count > 0) new Uint8Array(result, 0, count).set(new Uint8Array(receiver, start, count));
+          return result;
+        } finally {
+          release();
+        }
+      }
+    })
+  });
   Object.defineProperty(prototype, "resize", {
     writable: true,
     configurable: true,
@@ -42265,4 +42338,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-CYVI4ZUK.js.map
+//# sourceMappingURL=chunk-J5UIUYUC.js.map