@poe-platform/safe-js 0.1.360 → 0.1.362

package/dist/safe-js/chunks/{chunk-JFOSC26Y.js → chunk-EF6FLPF6.js}

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

package/dist/safe-js/chunks/{chunk-RHEDM44A.js → chunk-QMF5YOGC.js}

@@ -14638,6 +14638,96 @@ async function callSetMethod(target, methodName, args, options, stack = []) {
   }
 }
 
+// packages/safe-js/src/interp/globals/uint8-hex.ts
+var hexDigits = "0123456789abcdef";
+function installUint8Hex(budget, constructor, prototype) {
+  const fromHex = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "fromHex",
+    length: 1,
+    call: ([text]) => {
+      if (typeof text !== "string") throw new TypeError("Hex input must be a string.");
+      if (text.length % 2 !== 0) throw new SyntaxError("Hex input must have an even length.");
+      checkTypedArrayAllocation(text.length / 2, budget, 1);
+      const value = new Uint8Array(text.length / 2);
+      decodeHexInto(text, value, budget);
+      setSandboxPrototype(value, prototype, budget);
+      return value;
+    }
+  });
+  Object.defineProperty(materializeFunctionProperties(constructor), "fromHex", {
+    value: fromHex,
+    writable: true,
+    configurable: true
+  });
+  registerIntrinsicFunction(budget, fromHex);
+  Object.defineProperties(prototype, {
+    toHex: {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name: "toHex",
+        length: 0,
+        call: (_args, context) => {
+          const value = uint8Receiver(context?.thisValue);
+          const { length } = typedArrayStorage(value, true);
+          budget.provisionDataUsage(length * 2)();
+          let result = "";
+          for (let index = 0; index < length; index++) {
+            budget.visitNode();
+            const byte = value[index];
+            result = budget.allocateString(result + hexDigits[byte >> 4] + hexDigits[byte & 15]);
+          }
+          return result;
+        }
+      })
+    },
+    setFromHex: {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name: "setFromHex",
+        length: 1,
+        call: ([text], context) => {
+          const value = uint8Receiver(context?.thisValue);
+          if (typeof text !== "string") throw new TypeError("Hex input must be a string.");
+          typedArrayStorage(value, true);
+          const written = decodeHexInto(text, value, budget);
+          return { read: written * 2, written };
+        }
+      })
+    }
+  });
+}
+function uint8Receiver(value) {
+  if (!isNumericTypedArray(value) || typedArrayStorage(value).Native !== Uint8Array)
+    throw new TypeError("Hex conversion requires a Uint8Array receiver.");
+  return value;
+}
+function decodeHexInto(text, value, budget) {
+  if (text.length % 2 !== 0) throw new SyntaxError("Hex input must have an even length.");
+  const length = Math.min(text.length / 2, typedArrayStorage(value).length);
+  for (let index = 0; index < length; index++) {
+    budget.visitNode();
+    const high = hexNibble(text.charCodeAt(index * 2));
+    const low = hexNibble(text.charCodeAt(index * 2 + 1));
+    if (high < 0 || low < 0) throw new SyntaxError("Invalid hexadecimal digit.");
+    value[index] = high * 16 + low;
+  }
+  return length;
+}
+function hexNibble(code) {
+  if (code >= 48 && code <= 57) return code - 48;
+  if (code >= 65 && code <= 70) return code - 55;
+  if (code >= 97 && code <= 102) return code - 87;
+  return -1;
+}
+
 // packages/safe-js/src/interp/globals/numeric-typed-array.ts
 var constructors = /* @__PURE__ */ new WeakMap();
 function createNumericTypedArrayGlobal(budget, nativePrototype = false, Native = Float32Array) {
@@ -14903,8 +14993,11 @@ function createNumericTypedArrayPrototypes(budget, bindings) {
     setSandboxPrototype(constructor, typedArray);
     setSandboxPrototype(prototype, shared);
     prototypes2.set(Native, prototype);
-    registerIntrinsicFunction(budget, constructor);
-    registerIntrinsicObject(budget, prototype);
+  }
+  installUint8Hex(budget, bindings.Uint8Array, prototypes2.get(Uint8Array));
+  for (const [name, Native] of Object.entries(numericTypedArrayConstructors)) {
+    registerIntrinsicFunction(budget, bindings[name]);
+    registerIntrinsicObject(budget, prototypes2.get(Native));
   }
   Object.defineProperty(shared, "constructor", { value: typedArray, writable: true, configurable: true });
   setSandboxPrototype(shared, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
@@ -19703,6 +19796,7 @@ function typeTag(value, builtinOnly = false) {
 
 // packages/safe-js/src/interp/exceptions.ts
 var capturedExceptionBrand = /* @__PURE__ */ Symbol("CapturedException");
+var readDOMExceptionCode = Object.getOwnPropertyDescriptor(DOMException.prototype, "code").get;
 internalSymbols.add(capturedExceptionBrand);
 async function evaluateThrowStatement(node, context, evaluateNode2) {
   const argument = await evaluateNode2(node.argument, context);
@@ -19815,11 +19909,14 @@ function coerceThrownValue(reason, budget, stackFrames, span, sandbox = false) {
     return reason;
   }
   if (reason instanceof Error) {
-    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
+    const error = createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
       chargeBudget: false,
       cause: readErrorCause(reason),
       span
     });
+    if (reason instanceof DOMException)
+      Object.defineProperty(error, "code", { value: Reflect.apply(readDOMExceptionCode, reason, []), enumerable: true });
+    return error;
   }
   if (sandbox) {
     return reason;
@@ -28135,6 +28232,14 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
   if (isNumericTypedArray(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
+    if (state.structuredClone) {
+      try {
+        typedArrayStorage(value, true);
+      } catch (error) {
+        if (!(error instanceof TypeError)) throw error;
+        throw new DOMException("Cannot clone an out-of-bounds typed array.", "DataCloneError");
+      }
+    }
     const copy = copyTypedArrayStorage(value, state);
     state.seen.set(value, copy);
     if (state.structuredClone) return copy;
@@ -42816,4 +42921,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-RHEDM44A.js.map
+//# sourceMappingURL=chunk-QMF5YOGC.js.map