@sip-protocol/sdk 0.2.9 → 0.2.10

package/dist/{chunk-KXN6IWL5.mjs → chunk-AV37IZST.mjs}

@@ -3031,6 +3031,280 @@ var MockProofProvider = class {
 };
 
 // src/proofs/browser-utils.ts
+function detectMobilePlatform() {
+  if (typeof navigator === "undefined") return "desktop";
+  const ua = navigator.userAgent.toLowerCase();
+  if (/iphone|ipad|ipod/.test(ua) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) {
+    return "ios";
+  }
+  if (/android/.test(ua)) {
+    return "android";
+  }
+  if (/mobile|webos|blackberry|opera mini|opera mobi|iemobile|wpdesktop/.test(ua)) {
+    return "other";
+  }
+  return "desktop";
+}
+function detectMobileBrowser() {
+  if (typeof navigator === "undefined") return "other";
+  const ua = navigator.userAgent.toLowerCase();
+  if (/safari/.test(ua) && /iphone|ipad|ipod/.test(ua) && !/crios|fxios/.test(ua)) {
+    return "safari";
+  }
+  if (/chrome|crios/.test(ua) && !/edg|opr|samsung/.test(ua)) {
+    return "chrome";
+  }
+  if (/firefox|fxios/.test(ua)) {
+    return "firefox";
+  }
+  if (/samsung/.test(ua)) {
+    return "samsung";
+  }
+  if (/opr|opera/.test(ua)) {
+    return "opera";
+  }
+  if (/edg/.test(ua)) {
+    return "edge";
+  }
+  return "other";
+}
+function getBrowserVersion() {
+  if (typeof navigator === "undefined") return null;
+  const ua = navigator.userAgent;
+  const browser = detectMobileBrowser();
+  const patterns = {
+    safari: /version\/(\d+(\.\d+)*)/i,
+    chrome: /chrome\/(\d+(\.\d+)*)|crios\/(\d+(\.\d+)*)/i,
+    firefox: /firefox\/(\d+(\.\d+)*)|fxios\/(\d+(\.\d+)*)/i,
+    samsung: /samsungbrowser\/(\d+(\.\d+)*)/i,
+    opera: /opr\/(\d+(\.\d+)*)/i,
+    edge: /edg\/(\d+(\.\d+)*)/i,
+    other: /version\/(\d+(\.\d+)*)/i
+  };
+  const pattern = patterns[browser] || patterns.other;
+  const match = ua.match(pattern);
+  if (match) {
+    for (let i = 1; i < match.length; i++) {
+      if (match[i]) return match[i];
+    }
+  }
+  return null;
+}
+function getOSVersion() {
+  if (typeof navigator === "undefined") return null;
+  const ua = navigator.userAgent;
+  const platform = detectMobilePlatform();
+  if (platform === "ios") {
+    const match = ua.match(/os (\d+[_\d]*)/i);
+    return match ? match[1].replace(/_/g, ".") : null;
+  }
+  if (platform === "android") {
+    const match = ua.match(/android (\d+(\.\d+)*)/i);
+    return match ? match[1] : null;
+  }
+  return null;
+}
+function isTablet() {
+  if (typeof navigator === "undefined") return false;
+  const ua = navigator.userAgent.toLowerCase();
+  if (/ipad/.test(ua) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) {
+    return true;
+  }
+  if (/android/.test(ua) && !/mobile/.test(ua)) {
+    return true;
+  }
+  return false;
+}
+function supportsTouch() {
+  if (typeof window === "undefined") return false;
+  return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+}
+function getMobileDeviceInfo() {
+  const platform = detectMobilePlatform();
+  return {
+    isMobile: platform !== "desktop",
+    platform,
+    browser: detectMobileBrowser(),
+    browserVersion: getBrowserVersion(),
+    osVersion: getOSVersion(),
+    isTablet: isTablet(),
+    supportsTouch: supportsTouch(),
+    deviceMemoryGB: (
+      // @ts-expect-error - deviceMemory is non-standard
+      typeof navigator !== "undefined" && navigator.deviceMemory ? (
+        // @ts-expect-error - deviceMemory is non-standard
+        navigator.deviceMemory
+      ) : null
+    ),
+    hardwareConcurrency: typeof navigator !== "undefined" && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : null
+  };
+}
+function supportsWASMSimd() {
+  try {
+    return WebAssembly.validate(
+      new Uint8Array([
+        0,
+        97,
+        115,
+        109,
+        1,
+        0,
+        0,
+        0,
+        1,
+        5,
+        1,
+        96,
+        0,
+        1,
+        123,
+        3,
+        2,
+        1,
+        0,
+        10,
+        10,
+        1,
+        8,
+        0,
+        65,
+        0,
+        253,
+        15,
+        253,
+        98,
+        11
+      ])
+    );
+  } catch {
+    return false;
+  }
+}
+function supportsWASMBulkMemory() {
+  try {
+    return WebAssembly.validate(
+      new Uint8Array([
+        0,
+        97,
+        115,
+        109,
+        1,
+        0,
+        0,
+        0,
+        1,
+        4,
+        1,
+        96,
+        0,
+        0,
+        3,
+        2,
+        1,
+        0,
+        5,
+        3,
+        1,
+        0,
+        1,
+        10,
+        13,
+        1,
+        11,
+        0,
+        65,
+        0,
+        65,
+        0,
+        65,
+        0,
+        252,
+        11,
+        0,
+        11
+      ])
+    );
+  } catch {
+    return false;
+  }
+}
+function checkMobileWASMCompatibility() {
+  const issues = [];
+  const recommendations = [];
+  let score = 100;
+  const webAssembly = typeof WebAssembly !== "undefined";
+  if (!webAssembly) {
+    issues.push("WebAssembly not supported");
+    score -= 50;
+  }
+  const sharedArrayBuffer = supportsSharedArrayBuffer();
+  if (!sharedArrayBuffer) {
+    issues.push("SharedArrayBuffer not available (requires COOP/COEP headers)");
+    recommendations.push("Server must send Cross-Origin-Opener-Policy: same-origin");
+    recommendations.push("Server must send Cross-Origin-Embedder-Policy: require-corp");
+    score -= 20;
+  }
+  const webWorkers = supportsWebWorkers();
+  if (!webWorkers) {
+    issues.push("Web Workers not supported");
+    recommendations.push("Consider using a polyfill or fallback to main-thread execution");
+    score -= 15;
+  }
+  const simd = supportsWASMSimd();
+  if (!simd) {
+    recommendations.push("WASM SIMD not supported - proofs will be slower");
+    score -= 5;
+  }
+  const bulkMemory = supportsWASMBulkMemory();
+  if (!bulkMemory) {
+    recommendations.push("WASM bulk memory not supported - may affect performance");
+    score -= 5;
+  }
+  const bigInt = typeof BigInt !== "undefined";
+  if (!bigInt) {
+    issues.push("BigInt not supported (required for 64-bit operations)");
+    score -= 10;
+  }
+  const deviceInfo = getMobileDeviceInfo();
+  if (deviceInfo.isMobile) {
+    if (deviceInfo.deviceMemoryGB !== null && deviceInfo.deviceMemoryGB < 2) {
+      recommendations.push(`Low device memory (${deviceInfo.deviceMemoryGB}GB) - may experience issues with large proofs`);
+      score -= 5;
+    }
+    if (deviceInfo.platform === "ios" && deviceInfo.browser === "safari") {
+      if (!sharedArrayBuffer) {
+        recommendations.push("iOS Safari requires iOS 15.2+ for SharedArrayBuffer support");
+      }
+    }
+    if (deviceInfo.platform === "android" && deviceInfo.browser === "chrome") {
+      if (!sharedArrayBuffer) {
+        recommendations.push("Ensure COOP/COEP headers are set - Chrome Android requires them");
+      }
+    }
+  }
+  let summary;
+  if (score >= 90) {
+    summary = "Excellent - Full WASM proof support";
+  } else if (score >= 70) {
+    summary = "Good - WASM proofs supported with minor limitations";
+  } else if (score >= 50) {
+    summary = "Limited - WASM proofs may work with reduced performance";
+  } else {
+    summary = "Poor - WASM proofs not recommended on this device";
+  }
+  return {
+    webAssembly,
+    sharedArrayBuffer,
+    webWorkers,
+    simd,
+    bulkMemory,
+    bigInt,
+    score: Math.max(0, score),
+    summary,
+    issues,
+    recommendations
+  };
+}
 function hexToBytes5(hex) {
   const h = hex.startsWith("0x") ? hex.slice(2) : hex;
   if (h.length === 0) return new Uint8Array(0);
@@ -10612,6 +10886,16 @@ export {
   createSIP,
   createProductionSIP,
   MockProofProvider,
+  detectMobilePlatform,
+  detectMobileBrowser,
+  getBrowserVersion,
+  getOSVersion,
+  isTablet,
+  supportsTouch,
+  getMobileDeviceInfo,
+  supportsWASMSimd,
+  supportsWASMBulkMemory,
+  checkMobileWASMCompatibility,
   hexToBytes5 as hexToBytes,
   bytesToHex7 as bytesToHex,
   isBrowser,