device-passport 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -1,3254 +1,13 @@
 'use strict';
 
-const node_crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-const path__default = /*#__PURE__*/_interopDefaultCompat(path);
-
-const CANONICAL_HEADER_ORDER = [
-  // HTTP/2 Pseudo-headers (if provided)
-  ":method",
-  ":authority",
-  ":scheme",
-  ":path",
-  // Client Hints block (low-entropy)
-  "sec-ch-ua",
-  "sec-ch-ua-mobile",
-  "sec-ch-ua-platform",
-  // Upgrade requests
-  "upgrade-insecure-requests",
-  // User-Agent
-  "user-agent",
-  // Accept
-  "accept",
-  // Sec-Fetch-* metadata block
-  "sec-fetch-site",
-  "sec-fetch-mode",
-  "sec-fetch-user",
-  "sec-fetch-dest",
-  // Client Hints high-entropy hints
-  "sec-ch-ua-arch",
-  "sec-ch-ua-bitness",
-  "sec-ch-ua-model",
-  "sec-ch-ua-platform-version",
-  "sec-ch-ua-full-version-list",
-  "sec-ch-ua-wow64",
-  // Navigation context
-  "referer",
-  "origin",
-  // Encoding & Localization
-  "accept-encoding",
-  "accept-language",
-  // Chromium priority hint
-  "priority",
-  // Stateful session headers
-  "cookie",
-  "authorization",
-  "connection",
-  "cache-control",
-  "pragma"
-];
-function formatCanonicalHeaders(baseHeaders, overrides) {
-  const merged = {};
-  for (const [key, val] of Object.entries(baseHeaders)) {
-    if (val !== void 0 && val !== null) {
-      merged[key.toLowerCase()] = String(val);
-    }
-  }
-  if (overrides) {
-    for (const [key, val] of Object.entries(overrides)) {
-      if (val !== void 0 && val !== null) {
-        merged[key.toLowerCase()] = String(val);
-      }
-    }
-  }
-  const ordered = {};
-  for (const canonicalKey of CANONICAL_HEADER_ORDER) {
-    if (canonicalKey in merged) {
-      ordered[canonicalKey] = merged[canonicalKey];
-      delete merged[canonicalKey];
-    }
-  }
-  for (const [remainingKey, val] of Object.entries(merged)) {
-    ordered[remainingKey] = val;
-  }
-  return ordered;
-}
-function normalizeHeadersInput(headers) {
-  if (!headers) return {};
-  if (typeof Headers !== "undefined" && headers instanceof Headers) {
-    const res = {};
-    headers.forEach((val, key) => {
-      res[key] = val;
-    });
-    return res;
-  }
-  if (Array.isArray(headers)) {
-    const res = {};
-    for (const [k, v] of headers) {
-      res[k] = v;
-    }
-    return res;
-  }
-  return { ...headers };
-}
-function withPassport(passport, customFetch) {
-  const fetchImpl = customFetch ?? (typeof globalThis.fetch !== "undefined" ? globalThis.fetch : void 0);
-  if (!fetchImpl) {
-    throw new Error(
-      "[device-passport] Global fetch is not available. Please pass a custom fetch implementation to withPassport(passport, customFetch)."
-    );
-  }
-  return async function passportFetch(input, init) {
-    const explicitHeaders = normalizeHeadersInput(init?.headers);
-    const canonicalHeaders = typeof passport.getHeaders === "function" ? passport.getHeaders(explicitHeaders) : formatCanonicalHeaders(passport.headers, explicitHeaders);
-    if (typeof Request !== "undefined" && input instanceof Request) {
-      const requestHeaders = normalizeHeadersInput(input.headers);
-      const mergedHeaders = formatCanonicalHeaders(canonicalHeaders, requestHeaders);
-      const clonedInit = {
-        ...init,
-        headers: mergedHeaders
-      };
-      return fetchImpl(input, clonedInit);
-    }
-    return fetchImpl(input, {
-      ...init,
-      headers: canonicalHeaders
-    });
-  };
-}
-function toCurl(passport, url, options) {
-  const method = options?.method?.toUpperCase() ?? "GET";
-  const explicitHeaders = options?.headers ?? {};
-  const canonicalHeaders = typeof passport.getHeaders === "function" ? passport.getHeaders(explicitHeaders) : formatCanonicalHeaders(passport.headers, explicitHeaders);
-  const parts = ["curl", "-sSL"];
-  if (method !== "GET") {
-    parts.push(`-X ${method}`);
-  }
-  parts.push(`'${url}'`);
-  for (const [k, v] of Object.entries(canonicalHeaders)) {
-    const safeVal = String(v).replace(/'/g, `'\\''`);
-    parts.push(`-H '${k}: ${safeVal}'`);
-  }
-  if (options?.data) {
-    const payload = typeof options.data === "string" ? options.data : JSON.stringify(options.data);
-    parts.push(`--data '${payload.replace(/'/g, `'\\''`)}'`);
-  }
-  return parts.join(" \\\n  ");
-}
-
-function getPlaywrightContext(passport) {
-  const headers = passport.context?.extraHTTPHeaders ?? passport.headers ?? {};
-  const canonicalHeaders = formatCanonicalHeaders(headers);
-  const width = passport.hardware?.screen?.width ?? passport.context?.viewport?.width ?? 1920;
-  const height = passport.hardware?.screen?.height ?? passport.context?.viewport?.height ?? 1080;
-  const dpr = passport.hardware?.screen?.dpr ?? passport.context?.deviceScaleFactor ?? 1;
-  return {
-    userAgent: passport.browser?.userAgent ?? passport.context?.userAgent,
-    viewport: {
-      width,
-      height
-    },
-    deviceScaleFactor: dpr,
-    locale: passport.locale?.language ?? passport.context?.locale ?? "en-US",
-    timezoneId: passport.locale?.timezone ?? passport.context?.timezoneId ?? "America/New_York",
-    geolocation: passport.context?.geolocation,
-    permissions: passport.context?.permissions ?? ["geolocation"],
-    extraHTTPHeaders: canonicalHeaders,
-    hasTouch: passport.context?.hasTouch ?? false,
-    isMobile: passport.context?.isMobile ?? false,
-    colorScheme: passport.context?.colorScheme ?? "light"
-  };
-}
-function getStealthScript(passport) {
-  const { hardware, os, locale, browser, clientHints } = passport;
-  const concurrency = hardware?.cpu?.concurrency ?? 8;
-  const memory = hardware?.memory?.deviceMemory ?? 8;
-  const screenWidth = hardware?.screen?.width ?? 1920;
-  const screenHeight = hardware?.screen?.height ?? 1080;
-  const availWidth = hardware?.screen?.availWidth ?? screenWidth;
-  const availHeight = hardware?.screen?.availHeight ?? screenHeight - 40;
-  const colorDepth = hardware?.screen?.colorDepth ?? 24;
-  const pixelDepth = hardware?.screen?.pixelDepth ?? 24;
-  const platform = os?.platform === "macOS" ? "MacIntel" : "Win32";
-  const languages = JSON.stringify(locale?.languages ?? ["en-US", "en"]);
-  const gpuVendor = hardware?.gpu?.vendor ?? "Google Inc. (Apple)";
-  const gpuRenderer = hardware?.gpu?.renderer ?? "ANGLE (Apple, Apple M2, OpenGL 4.1)";
-  const uachData = JSON.stringify({
-    brands: clientHints?.brands ?? [
-      { brand: "Chromium", version: String(browser?.majorVersion ?? 124) },
-      { brand: "Google Chrome", version: String(browser?.majorVersion ?? 124) },
-      { brand: "Not-A.Brand", version: "99" }
-    ],
-    mobile: clientHints?.mobile ?? false,
-    platform: clientHints?.platform ?? (os?.platform ?? "macOS"),
-    architecture: clientHints?.architecture ?? (os?.architecture ?? "arm"),
-    bitness: clientHints?.bitness ?? "64",
-    model: clientHints?.model ?? "",
-    platformVersion: clientHints?.platformVersion ?? (os?.version ?? "14.6.1"),
-    fullVersionList: clientHints?.fullVersionList ?? [
-      { brand: "Chromium", version: browser?.version ?? "124.0.6367.208" },
-      { brand: "Google Chrome", version: browser?.version ?? "124.0.6367.208" },
-      { brand: "Not-A.Brand", version: "99.0.0.0" }
-    ]
-  });
-  return `
-(() => {
-  // 1. Remove automation flags
-  try {
-    Object.defineProperty(navigator, 'webdriver', {
-      get: () => undefined,
-      configurable: true
-    });
-    delete (navigator as any).__proto__.webdriver;
-  } catch (e) {}
-
-  // 2. Hardware profile (CPU, Memory)
-  try {
-    Object.defineProperty(navigator, 'hardwareConcurrency', {
-      get: () => ${concurrency},
-      configurable: true
-    });
-    Object.defineProperty(navigator, 'deviceMemory', {
-      get: () => ${memory},
-      configurable: true
-    });
-  } catch (e) {}
-
-  // 3. Platform & Languages
-  try {
-    Object.defineProperty(navigator, 'platform', {
-      get: () => '${platform}',
-      configurable: true
-    });
-    const langs = ${languages};
-    Object.defineProperty(navigator, 'languages', {
-      get: () => langs,
-      configurable: true
-    });
-    Object.defineProperty(navigator, 'language', {
-      get: () => langs[0],
-      configurable: true
-    });
-  } catch (e) {}
-
-  // 4. Screen properties
-  try {
-    Object.defineProperty(window.screen, 'width', { get: () => ${screenWidth}, configurable: true });
-    Object.defineProperty(window.screen, 'height', { get: () => ${screenHeight}, configurable: true });
-    Object.defineProperty(window.screen, 'availWidth', { get: () => ${availWidth}, configurable: true });
-    Object.defineProperty(window.screen, 'availHeight', { get: () => ${availHeight}, configurable: true });
-    Object.defineProperty(window.screen, 'colorDepth', { get: () => ${colorDepth}, configurable: true });
-    Object.defineProperty(window.screen, 'pixelDepth', { get: () => ${pixelDepth}, configurable: true });
-  } catch (e) {}
-
-  // 5. Client Hints (navigator.userAgentData)
-  try {
-    const hintData = ${uachData};
-    if (typeof (navigator as any).userAgentData !== 'undefined' || true) {
-      const uach = {
-        brands: hintData.brands,
-        mobile: hintData.mobile,
-        platform: hintData.platform,
-        getHighEntropyValues: async (hints) => {
-          const res = {
-            brands: hintData.brands,
-            mobile: hintData.mobile,
-            platform: hintData.platform,
-          };
-          if (hints.includes('architecture')) res.architecture = hintData.architecture;
-          if (hints.includes('bitness')) res.bitness = hintData.bitness;
-          if (hints.includes('model')) res.model = hintData.model;
-          if (hints.includes('platformVersion')) res.platformVersion = hintData.platformVersion;
-          if (hints.includes('fullVersionList')) res.fullVersionList = hintData.fullVersionList;
-          return res;
-        },
-        toJSON: () => ({
-          brands: hintData.brands,
-          mobile: hintData.mobile,
-          platform: hintData.platform,
-        })
-      };
-      Object.defineProperty(navigator, 'userAgentData', {
-        get: () => uach,
-        configurable: true
-      });
-    }
-  } catch (e) {}
-
-  // 6. WebGL Vendor & Renderer spoofing
-  try {
-    const getParameterProto = WebGLRenderingContext.prototype.getParameter;
-    const vendorParam = 0x9245; // UNMASKED_VENDOR_WEBGL
-    const rendererParam = 0x9246; // UNMASKED_RENDERER_WEBGL
-
-    WebGLRenderingContext.prototype.getParameter = function(parameter) {
-      if (parameter === vendorParam) return '${gpuVendor}';
-      if (parameter === rendererParam) return '${gpuRenderer}';
-      return getParameterProto.apply(this, arguments);
-    };
-
-    if (typeof WebGL2RenderingContext !== 'undefined') {
-      const getParameter2Proto = WebGL2RenderingContext.prototype.getParameter;
-      WebGL2RenderingContext.prototype.getParameter = function(parameter) {
-        if (parameter === vendorParam) return '${gpuVendor}';
-        if (parameter === rendererParam) return '${gpuRenderer}';
-        return getParameter2Proto.apply(this, arguments);
-      };
-    }
-  } catch (e) {}
-
-  // 7. Chrome runtime mock for Chromium personas
-  try {
-    if (!window.chrome) {
-      (window as any).chrome = {
-        app: { isInstalled: false, InstallState: { DISABLED: 'disabled', INSTALLED: 'installed', NOT_INSTALLED: 'not_installed' } },
-        runtime: { OnInstalledReason: {}, OnRestartRequiredReason: {} },
-        loadTimes: () => ({}),
-        csi: () => ({}),
-      };
-    }
-  } catch (e) {}
-})();
-`;
-}
-async function applyToPlaywrightContext(context, passport) {
-  if (!context || typeof context.addInitScript !== "function") {
-    throw new Error("[device-passport] Invalid Playwright context provided to applyToPlaywrightContext.");
-  }
-  const stealthScript = getStealthScript(passport);
-  await context.addInitScript(stealthScript);
-  const headers = passport.context?.extraHTTPHeaders ?? passport.headers ?? {};
-  if (typeof context.setExtraHTTPHeaders === "function") {
-    await context.setExtraHTTPHeaders(formatCanonicalHeaders(headers));
-  }
-}
-
-function getPuppeteerArgs(passport) {
-  const width = passport.hardware?.screen?.width ?? 1920;
-  const height = passport.hardware?.screen?.height ?? 1080;
-  const dpr = passport.hardware?.screen?.dpr ?? 1;
-  const locale = passport.locale?.language ?? "en-US";
-  const timezone = passport.locale?.timezone ?? "America/New_York";
-  const userAgent = passport.browser?.userAgent ?? passport.context?.userAgent;
-  const headers = passport.context?.extraHTTPHeaders ?? passport.headers ?? {};
-  const canonicalHeaders = formatCanonicalHeaders(headers);
-  const launchArgs = [
-    `--user-agent=${userAgent}`,
-    `--window-size=${width},${height}`,
-    `--lang=${locale}`,
-    "--disable-blink-features=AutomationControlled",
-    "--no-default-browser-check"
-  ];
-  return {
-    launchArgs,
-    defaultViewport: {
-      width,
-      height,
-      deviceScaleFactor: dpr,
-      isMobile: passport.context?.isMobile ?? false,
-      hasTouch: passport.context?.hasTouch ?? false
-    },
-    userAgent,
-    locale,
-    timezoneId: timezone,
-    extraHTTPHeaders: canonicalHeaders
-  };
-}
-async function applyToPuppeteerPage(page, passport) {
-  if (!page || typeof page.evaluateOnNewDocument !== "function") {
-    throw new Error("[device-passport] Invalid Puppeteer page provided to applyToPuppeteerPage.");
-  }
-  const { defaultViewport, userAgent, extraHTTPHeaders, timezoneId } = getPuppeteerArgs(passport);
-  if (typeof page.setUserAgent === "function") {
-    await page.setUserAgent(userAgent);
-  }
-  if (typeof page.setViewport === "function") {
-    await page.setViewport(defaultViewport);
-  }
-  if (typeof page.setExtraHTTPHeaders === "function") {
-    await page.setExtraHTTPHeaders(extraHTTPHeaders);
-  }
-  if (typeof page.emulateTimezone === "function") {
-    try {
-      await page.emulateTimezone(timezoneId);
-    } catch {
-    }
-  }
-  const stealthScript = getStealthScript(passport);
-  await page.evaluateOnNewDocument(stealthScript);
-}
-
-const COUNTRY_TIMEZONE_MAP = {
-  US: [
-    "America/New_York",
-    "America/Chicago",
-    "America/Denver",
-    "America/Los_Angeles",
-    "America/Anchorage",
-    "America/Phoenix",
-    "America/Detroit",
-    "America/Indiana/Indianapolis",
-    "Pacific/Honolulu"
-  ],
-  CA: [
-    "America/Toronto",
-    "America/Vancouver",
-    "America/Montreal",
-    "America/Edmonton",
-    "America/Winnipeg",
-    "America/Halifax",
-    "America/St_Johns"
-  ],
-  GB: ["Europe/London"],
-  UK: ["Europe/London"],
-  DE: ["Europe/Berlin"],
-  FR: ["Europe/Paris"],
-  JP: ["Asia/Tokyo"],
-  CN: ["Asia/Shanghai", "Asia/Chongqing", "Asia/Urumqi", "Asia/Harbin"],
-  AU: [
-    "Australia/Sydney",
-    "Australia/Melbourne",
-    "Australia/Brisbane",
-    "Australia/Perth",
-    "Australia/Adelaide"
-  ],
-  SG: ["Asia/Singapore"],
-  HK: ["Asia/Hong_Kong"],
-  TW: ["Asia/Taipei"],
-  KR: ["Asia/Seoul"],
-  NL: ["Europe/Amsterdam"],
-  SE: ["Europe/Stockholm"],
-  CH: ["Europe/Zurich"],
-  BR: ["America/Sao_Paulo", "America/Manaus", "America/Fortaleza"],
-  IN: ["Asia/Kolkata"],
-  RU: ["Europe/Moscow", "Asia/Yekaterinburg", "Asia/Novosibirsk", "Asia/Vladivostok"]
-};
-const COUNTRY_PRIMARY_LANGUAGES = {
-  US: ["en", "en-US"],
-  CA: ["en", "en-CA", "fr", "fr-CA"],
-  GB: ["en", "en-GB"],
-  UK: ["en", "en-GB"],
-  DE: ["de", "de-DE"],
-  FR: ["fr", "fr-FR"],
-  JP: ["ja", "ja-JP"],
-  CN: ["zh", "zh-CN", "zh-Hans"],
-  TW: ["zh", "zh-TW", "zh-Hant"],
-  HK: ["zh", "zh-HK", "en"],
-  KR: ["ko", "ko-KR"],
-  SG: ["en", "en-SG", "zh", "zh-SG"],
-  AU: ["en", "en-AU"],
-  NL: ["nl", "nl-NL", "en"],
-  SE: ["sv", "sv-SE", "en"],
-  CH: ["de", "de-CH", "fr", "fr-CH", "it", "it-CH"],
-  BR: ["pt", "pt-BR"],
-  IN: ["en", "en-IN", "hi", "hi-IN"],
-  RU: ["ru", "ru-RU"]
-};
-function detectOSBrowserContradictions(passport) {
-  const contradictions = [];
-  const { browser, os, headers, clientHints } = passport;
-  if (browser.name === "Safari" && os.platform !== "macOS") {
-    contradictions.push({
-      id: "ERR_SAFARI_NON_APPLE_PLATFORM",
-      category: "os_browser",
-      severity: "fatal",
-      description: `Safari modern releases are exclusive to macOS/iOS; cannot run on ${os.platform}`,
-      fields: ["browser.name", "os.platform"],
-      actual: { browser: browser.name, platform: os.platform },
-      expected: "macOS",
-      impactPenalty: 35
-    });
-  }
-  if (browser.name === "Chrome" || browser.name === "Edge") {
-    if (browser.majorVersion >= 110 && os.release) {
-      const isLegacyWin = /Windows (7|8|XP|Vista)/i.test(os.release);
-      if (isLegacyWin) {
-        contradictions.push({
-          id: "ERR_CHROME_LEGACY_WIN_UNSUPPORTED",
-          category: "os_browser",
-          severity: "fatal",
-          description: `Chromium ${browser.majorVersion} requires Windows 10 or later; unsupported on ${os.release}`,
-          fields: ["browser.majorVersion", "os.release"],
-          actual: { browserVersion: browser.majorVersion, osRelease: os.release },
-          expected: "Windows 10 or Windows 11",
-          impactPenalty: 30
-        });
-      }
-    }
-    if (browser.majorVersion >= 120 && os.platform === "macOS") {
-      const match = os.version.match(/^(\d+)/);
-      if (match && parseInt(match[1], 10) < 11) {
-        contradictions.push({
-          id: "ERR_CHROME_LEGACY_MACOS_UNSUPPORTED",
-          category: "os_browser",
-          severity: "high",
-          description: `Chromium ${browser.majorVersion} requires macOS 11.0 (Big Sur) or higher; got macOS ${os.version}`,
-          fields: ["browser.majorVersion", "os.version"],
-          actual: os.version,
-          expected: ">= 11.0.0",
-          impactPenalty: 25
-        });
-      }
-    }
-  }
-  const ua = browser.userAgent || headers["user-agent"] || "";
-  if (os.platform === "macOS" && !/Macintosh|Mac OS X/i.test(ua)) {
-    contradictions.push({
-      id: "ERR_UA_OS_MACOS_MISMATCH",
-      category: "os_browser",
-      severity: "fatal",
-      description: "Operating system is macOS but User-Agent string does not indicate Macintosh architecture",
-      fields: ["os.platform", "browser.userAgent"],
-      actual: ua,
-      expected: 'Containing "Macintosh; Intel Mac OS X..."',
-      impactPenalty: 35
-    });
-  } else if (os.platform === "Windows" && !/Windows NT/i.test(ua)) {
-    contradictions.push({
-      id: "ERR_UA_OS_WINDOWS_MISMATCH",
-      category: "os_browser",
-      severity: "fatal",
-      description: "Operating system is Windows but User-Agent string does not contain Windows NT tag",
-      fields: ["os.platform", "browser.userAgent"],
-      actual: ua,
-      expected: 'Containing "Windows NT..."',
-      impactPenalty: 35
-    });
-  }
-  if (clientHints?.platformVersion && os.platform === "Windows") {
-    const pvMajor = parseInt(clientHints.platformVersion.split(".")[0], 10);
-    const isWin11 = /Windows 11/i.test(os.release);
-    const isWin10 = /Windows 10/i.test(os.release);
-    if (isWin11 && pvMajor < 13) {
-      contradictions.push({
-        id: "ERR_WIN11_PLATFORM_VERSION_MISMATCH",
-        category: "os_browser",
-        severity: "high",
-        description: `Windows 11 reports Client-Hints platformVersion >= 13.0.0 (e.g. 15.0.0), but received "${clientHints.platformVersion}"`,
-        fields: ["os.release", "clientHints.platformVersion"],
-        actual: clientHints.platformVersion,
-        expected: ">= 13.0.0 (typically 14.0.0 or 15.0.0)",
-        impactPenalty: 20
-      });
-    } else if (isWin10 && pvMajor >= 13) {
-      contradictions.push({
-        id: "ERR_WIN10_PLATFORM_VERSION_MISMATCH",
-        category: "os_browser",
-        severity: "high",
-        description: `Windows 10 reports Client-Hints platformVersion <= 10.0.0, but received Windows 11 platformVersion "${clientHints.platformVersion}"`,
-        fields: ["os.release", "clientHints.platformVersion"],
-        actual: clientHints.platformVersion,
-        expected: "10.0.0 (or 1.0.0 - 10.0.0)",
-        impactPenalty: 20
-      });
-    }
-  }
-  return contradictions;
-}
-function detectHardwareContradictions(passport) {
-  const contradictions = [];
-  const { hardware, os, clientHints } = passport;
-  if (os.platform === "macOS") {
-    const isAppleSiliconGpu = /Apple M\d/i.test(hardware.gpu.renderer);
-    if (isAppleSiliconGpu && hardware.cpu.architecture === "x86" && clientHints?.architecture === "x86") {
-      contradictions.push({
-        id: "ERR_APPLE_SILICON_X86_CONTRADICTION",
-        category: "hardware_system",
-        severity: "high",
-        description: `Apple Silicon GPU detected (${hardware.gpu.renderer}) but native CPU architecture and Client Hint reported as x86`,
-        fields: ["hardware.gpu.renderer", "hardware.cpu.architecture", "clientHints.architecture"],
-        actual: { gpu: hardware.gpu.renderer, arch: hardware.cpu.architecture },
-        expected: "arm",
-        impactPenalty: 20
-      });
-    }
-  }
-  const gpuRenderer = hardware.gpu.renderer || "";
-  if (os.platform === "macOS") {
-    if (/GeForce RTX|GTX 16|RTX 30|RTX 40/i.test(gpuRenderer)) {
-      contradictions.push({
-        id: "ERR_NVIDIA_MODERN_ON_MACOS",
-        category: "hardware_system",
-        severity: "fatal",
-        description: `NVIDIA modern GPUs (${gpuRenderer}) have no driver support on modern macOS`,
-        fields: ["hardware.gpu.renderer", "os.platform"],
-        actual: gpuRenderer,
-        expected: "Apple M-Series GPU or AMD Radeon Pro (legacy Intel Mac)",
-        impactPenalty: 35
-      });
-    }
-    if (/Direct3D|D3D11|D3D12/i.test(gpuRenderer)) {
-      contradictions.push({
-        id: "ERR_DIRECT3D_ON_MACOS",
-        category: "hardware_system",
-        severity: "fatal",
-        description: `Direct3D/DirectX renderer (${gpuRenderer}) cannot exist on macOS WebGL pipeline`,
-        fields: ["hardware.gpu.renderer", "os.platform"],
-        actual: gpuRenderer,
-        expected: "Metal or OpenGL ANGLE backend",
-        impactPenalty: 30
-      });
-    }
-  } else if (os.platform === "Windows") {
-    if (/Apple M\d/i.test(gpuRenderer)) {
-      contradictions.push({
-        id: "ERR_APPLE_GPU_ON_WINDOWS",
-        category: "hardware_system",
-        severity: "fatal",
-        description: `Apple Silicon integrated graphics (${gpuRenderer}) cannot run under Microsoft Windows`,
-        fields: ["hardware.gpu.renderer", "os.platform"],
-        actual: gpuRenderer,
-        expected: "Intel UHD/Iris, NVIDIA GeForce, or AMD Radeon",
-        impactPenalty: 35
-      });
-    }
-  }
-  if (clientHints?.architecture && hardware.cpu.architecture) {
-    if (clientHints.architecture !== hardware.cpu.architecture) {
-      contradictions.push({
-        id: "ERR_CH_ARCH_HARDWARE_MISMATCH",
-        category: "hardware_system",
-        severity: "fatal",
-        description: `sec-ch-ua-arch ("${clientHints.architecture}") does not match CPU hardware concurrency profile ("${hardware.cpu.architecture}")`,
-        fields: ["clientHints.architecture", "hardware.cpu.architecture"],
-        actual: clientHints.architecture,
-        expected: hardware.cpu.architecture,
-        impactPenalty: 30
-      });
-    }
-  }
-  const dm = hardware.memory.deviceMemory;
-  if (dm !== void 0) {
-    const validDeviceMemoryValues = [0.25, 0.5, 1, 2, 4, 8];
-    if (dm <= 0 || !validDeviceMemoryValues.includes(dm)) {
-      if (dm > 8) {
-        contradictions.push({
-          id: "WARN_DEVICE_MEMORY_UNCAPPED",
-          category: "hardware_system",
-          severity: "medium",
-          description: `navigator.deviceMemory reported as ${dm} GiB; standard Chromium caps deviceMemory at 8 GiB`,
-          fields: ["hardware.memory.deviceMemory"],
-          actual: dm,
-          expected: "Capped at 8 (one of [0.25, 0.5, 1, 2, 4, 8])",
-          impactPenalty: 10
-        });
-      }
-    }
-  }
-  const { screen } = hardware;
-  if (screen.width > 0 && screen.height > 0) {
-    if (screen.availWidth > screen.width || screen.availHeight > screen.height) {
-      contradictions.push({
-        id: "ERR_SCREEN_AVAILABLE_EXCEEDS_TOTAL",
-        category: "hardware_system",
-        severity: "high",
-        description: `Screen available dimensions (${screen.availWidth}x${screen.availHeight}) exceed screen total bounds (${screen.width}x${screen.height})`,
-        fields: ["hardware.screen.availWidth", "hardware.screen.width"],
-        actual: { avail: `${screen.availWidth}x${screen.availHeight}`, total: `${screen.width}x${screen.height}` },
-        expected: "availWidth <= width && availHeight <= height",
-        impactPenalty: 20
-      });
-    }
-    if (passport.context?.viewport) {
-      const vp = passport.context.viewport;
-      if (vp.width > screen.width || vp.height > screen.height) {
-        contradictions.push({
-          id: "ERR_VIEWPORT_EXCEEDS_SCREEN",
-          category: "hardware_system",
-          severity: "fatal",
-          description: `Browser viewport (${vp.width}x${vp.height}) exceeds physical display screen (${screen.width}x${screen.height})`,
-          fields: ["context.viewport", "hardware.screen"],
-          actual: `${vp.width}x${vp.height}`,
-          expected: `<= ${screen.width}x${screen.height}`,
-          impactPenalty: 30
-        });
-      }
-    }
-  }
-  return contradictions;
-}
-function detectGeoChronoContradictions(passport) {
-  const contradictions = [];
-  const { locale, headers } = passport;
-  const country = (locale.country || "").toUpperCase();
-  const timezone = locale.timezone || "";
-  if (country && timezone && COUNTRY_TIMEZONE_MAP[country]) {
-    const validTimezones = COUNTRY_TIMEZONE_MAP[country];
-    if (!validTimezones.includes(timezone)) {
-      contradictions.push({
-        id: "ERR_GEO_TIMEZONE_COUNTRY_MISMATCH",
-        category: "geo_chrono",
-        severity: "fatal",
-        description: `Timezone "${timezone}" does not belong to geographic territory "${country}"`,
-        fields: ["locale.timezone", "locale.country"],
-        actual: { country, timezone },
-        expected: validTimezones.join(", "),
-        impactPenalty: 40
-      });
-    }
-  }
-  const acceptLangHeader = headers["accept-language"] || "";
-  if (country && COUNTRY_PRIMARY_LANGUAGES[country]) {
-    const expectedLanguages = COUNTRY_PRIMARY_LANGUAGES[country];
-    const primaryLocaleLang = (locale.language || "").toLowerCase().split("-")[0];
-    const countryExpectsMatch = expectedLanguages.some(
-      (el) => primaryLocaleLang === el.toLowerCase().split("-")[0]
-    );
-    if (!countryExpectsMatch && primaryLocaleLang) {
-      contradictions.push({
-        id: "WARN_GEO_PRIMARY_LANGUAGE_MISMATCH",
-        category: "geo_chrono",
-        severity: "high",
-        description: `Primary locale language "${locale.language}" is anomalous for country code "${country}"`,
-        fields: ["locale.language", "locale.country"],
-        actual: locale.language,
-        expected: expectedLanguages.join(", "),
-        impactPenalty: 15
-      });
-    }
-    if (acceptLangHeader) {
-      const hasAnyExpectedInHeader = expectedLanguages.some(
-        (lang) => acceptLangHeader.toLowerCase().includes(lang.toLowerCase())
-      );
-      if (!hasAnyExpectedInHeader && !acceptLangHeader.toLowerCase().includes("en")) {
-        contradictions.push({
-          id: "WARN_ACCEPT_LANGUAGE_GEO_DETACHED",
-          category: "geo_chrono",
-          severity: "medium",
-          description: `Accept-Language header "${acceptLangHeader}" contains neither local language for "${country}" nor global fallback (en)`,
-          fields: ["headers.accept-language", "locale.country"],
-          actual: acceptLangHeader,
-          expected: `Includes one of: ${expectedLanguages.join(", ")} or en`,
-          impactPenalty: 12
-        });
-      }
-    }
-  }
-  return contradictions;
-}
-function detectClientHintsContradictions(passport) {
-  const contradictions = [];
-  const { clientHints, os } = passport;
-  if (!clientHints) return contradictions;
-  if (clientHints.mobile === true && (os.platform === "macOS" || os.platform === "Windows")) {
-    contradictions.push({
-      id: "ERR_CH_MOBILE_ON_DESKTOP",
-      category: "client_hints",
-      severity: "fatal",
-      description: `Client-Hints indicates mobile=true (?1) on desktop operating system ${os.platform}`,
-      fields: ["clientHints.mobile", "os.platform"],
-      actual: { mobile: clientHints.mobile, platform: os.platform },
-      expected: "mobile: false (?0)",
-      impactPenalty: 35
-    });
-  }
-  if (clientHints.platform) {
-    const chPlat = clientHints.platform.toLowerCase();
-    const osPlat = os.platform.toLowerCase();
-    if (chPlat !== osPlat) {
-      contradictions.push({
-        id: "ERR_CH_PLATFORM_OS_MISMATCH",
-        category: "client_hints",
-        severity: "fatal",
-        description: `sec-ch-ua-platform "${clientHints.platform}" contradicts OS platform "${os.platform}"`,
-        fields: ["clientHints.platform", "os.platform"],
-        actual: clientHints.platform,
-        expected: os.platform,
-        impactPenalty: 35
-      });
-    }
-  }
-  if ((os.platform === "macOS" || os.platform === "Windows") && clientHints.model && clientHints.model.trim() !== "") {
-    contradictions.push({
-      id: "ERR_CH_NON_EMPTY_DESKTOP_MODEL",
-      category: "client_hints",
-      severity: "high",
-      description: `Desktop Chromium mandates empty sec-ch-ua-model (""), received "${clientHints.model}"`,
-      fields: ["clientHints.model", "os.platform"],
-      actual: clientHints.model,
-      expected: '"" (empty string for desktop)',
-      impactPenalty: 25
-    });
-  }
-  if (clientHints.bitness && clientHints.bitness !== "64") {
-    if (os.platform === "macOS") {
-      contradictions.push({
-        id: "ERR_CH_32BIT_ON_MODERN_MACOS",
-        category: "client_hints",
-        severity: "fatal",
-        description: `macOS has discontinued 32-bit binaries since macOS 10.15; bitness reported as "${clientHints.bitness}"`,
-        fields: ["clientHints.bitness", "os.platform"],
-        actual: clientHints.bitness,
-        expected: '"64"',
-        impactPenalty: 30
-      });
-    }
-  }
-  return contradictions;
-}
-function detectAllContradictions(passport) {
-  return [
-    ...detectOSBrowserContradictions(passport),
-    ...detectHardwareContradictions(passport),
-    ...detectGeoChronoContradictions(passport),
-    ...detectClientHintsContradictions(passport)
-  ];
-}
-
-const BROWSER_BASELINE_FREQUENCIES = {
-  "sec-ch-ua": 0.12,
-  "sec-ch-ua-mobile": 0.04,
-  "sec-ch-ua-platform": 0.08,
-  "upgrade-insecure-requests": 0.04,
-  "user-agent": 0.22,
-  "accept": 0.14,
-  "sec-fetch-site": 0.05,
-  "sec-fetch-mode": 0.05,
-  "sec-fetch-user": 0.03,
-  "sec-fetch-dest": 0.05,
-  "accept-encoding": 0.08,
-  "accept-language": 0.1
-};
-const OPTIMAL_CHAR_ENTROPY_MIN = 4.6;
-const OPTIMAL_CHAR_ENTROPY_MAX = 5.6;
-const OPTIMAL_ENTROPY_MIN = OPTIMAL_CHAR_ENTROPY_MIN;
-const OPTIMAL_ENTROPY_MAX = OPTIMAL_CHAR_ENTROPY_MAX;
-const BASELINE_OPTIMAL_ENTROPY = 5.25;
-const MIN_STRUCTURAL_ENTROPY = 3.5;
-function calculateShannonEntropy(data) {
-  if (!data || data.length === 0) return 0;
-  const frequencies = /* @__PURE__ */ new Map();
-  const total = data.length;
-  for (let i = 0; i < total; i++) {
-    const char = data[i];
-    frequencies.set(char, (frequencies.get(char) || 0) + 1);
-  }
-  let entropy = 0;
-  for (const count of frequencies.values()) {
-    const p = count / total;
-    if (p > 0) {
-      entropy -= p * Math.log2(p);
-    }
-  }
-  return Number(entropy.toFixed(4));
-}
-function calculateStructuralEntropy(headers) {
-  const normalizedKeys = Object.keys(headers).map((k) => k.toLowerCase());
-  const baselineKeys = Object.keys(BROWSER_BASELINE_FREQUENCIES);
-  if (normalizedKeys.length === 0) return 0;
-  let presentCount = 0;
-  for (const key of baselineKeys) {
-    if (normalizedKeys.includes(key)) {
-      presentCount++;
-    }
-  }
-  const presenceRatio = presentCount / baselineKeys.length;
-  const countFactor = Math.min(normalizedKeys.length / 10, 1);
-  return Number((presenceRatio * 3 + countFactor * 2).toFixed(4));
-}
-function calculateKLDivergence(headers) {
-  const normalizedHeaders = {};
-  for (const [k, v] of Object.entries(headers)) {
-    normalizedHeaders[k.toLowerCase()] = v;
-  }
-  const baselineKeys = Object.keys(BROWSER_BASELINE_FREQUENCIES);
-  let totalLength = 0;
-  const observedLengths = {};
-  for (const key of baselineKeys) {
-    const val = normalizedHeaders[key] || "";
-    const len = val.length + key.length;
-    observedLengths[key] = len;
-    totalLength += len;
-  }
-  if (totalLength === 0) return 3.5;
-  let klDiv = 0;
-  const epsilon = 1e-4;
-  for (const key of baselineKeys) {
-    const p = (observedLengths[key] || 0) / totalLength + epsilon;
-    const q = BROWSER_BASELINE_FREQUENCIES[key] || epsilon;
-    klDiv += p * Math.log2(p / q);
-  }
-  return Number(Math.max(0, klDiv).toFixed(4));
-}
-function analyzeHeaderEntropy(headers) {
-  if (!headers || Object.keys(headers).length === 0) {
-    return {
-      entropyScore: 0,
-      estimatedBits: 0,
-      klDivergence: 4,
-      anomaly: "too_low",
-      collisionRisk: "high",
-      verdict: "Completely static or empty headers; trivially detectable as automated bot.",
-      details: {
-        characterEntropy: 0,
-        structuralEntropy: 0,
-        baselineEntropy: BASELINE_OPTIMAL_ENTROPY,
-        deltaFromOptimal: BASELINE_OPTIMAL_ENTROPY
-      }
-    };
-  }
-  const serialized = Object.entries(headers).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k.toLowerCase()}: ${v}`).join("\r\n");
-  const charEntropy = calculateShannonEntropy(serialized);
-  const structEntropy = calculateStructuralEntropy(headers);
-  const klDiv = calculateKLDivergence(headers);
-  const headerCount = Object.keys(headers).length;
-  let anomaly = "optimal";
-  let penalty = 0;
-  if (headerCount < 4 || structEntropy < MIN_STRUCTURAL_ENTROPY || charEntropy < OPTIMAL_CHAR_ENTROPY_MIN) {
-    anomaly = "too_low";
-    const structDeficit = Math.max(0, MIN_STRUCTURAL_ENTROPY - structEntropy);
-    penalty += structDeficit * 15;
-    const charDeficit = Math.max(0, OPTIMAL_CHAR_ENTROPY_MIN - charEntropy);
-    penalty += charDeficit * 25;
-    if (headerCount < 4) {
-      penalty += (4 - headerCount) * 15;
-    }
-  } else if (charEntropy > OPTIMAL_CHAR_ENTROPY_MAX) {
-    anomaly = "too_high";
-    const excess = charEntropy - OPTIMAL_CHAR_ENTROPY_MAX;
-    penalty += excess * 30;
-  }
-  penalty += Math.min(klDiv * 12, 30);
-  const rawScore = 100 - penalty;
-  const entropyScore = Number(Math.max(0, Math.min(100, rawScore)).toFixed(1));
-  let collisionRisk = "very_low";
-  let verdict = "Realistic entropy distribution matching authentic browser telemetry.";
-  if (anomaly === "too_low") {
-    collisionRisk = "high";
-    verdict = "Under-randomized or missing essential browser headers; high risk of bot detection.";
-  } else if (anomaly === "too_high") {
-    collisionRisk = "moderate";
-    verdict = "Hyper-randomized noise detected; synthetic fingerprint spoofing risk.";
-  } else if (entropyScore >= 85) {
-    collisionRisk = "very_low";
-    verdict = "Optimal information entropy perfectly consistent with real Chromium/Safari sessions.";
-  } else {
-    collisionRisk = "low";
-    verdict = "Acceptable entropy band with minor structural divergence.";
-  }
-  return {
-    entropyScore,
-    estimatedBits: charEntropy,
-    klDivergence: klDiv,
-    anomaly,
-    collisionRisk,
-    verdict,
-    details: {
-      characterEntropy: charEntropy,
-      structuralEntropy: structEntropy,
-      baselineEntropy: BASELINE_OPTIMAL_ENTROPY,
-      deltaFromOptimal: Number(Math.abs(charEntropy - BASELINE_OPTIMAL_ENTROPY).toFixed(4))
-    }
-  };
-}
-
-const GREASE_BRANDS = [
-  "Not/A)Brand",
-  "Not_A Brand",
-  "Not?A_Brand",
-  "Not.A/Brand",
-  "Not:A-Brand"
-];
-function generateBrandVersions(browserName, majorVersion, fullVersion, prng = Math.random) {
-  const greaseIdx = Math.floor(prng() * GREASE_BRANDS.length);
-  const greaseBrand = GREASE_BRANDS[greaseIdx] ?? "Not/A)Brand";
-  const greaseMajor = "8";
-  const greaseFull = "8.0.0.0";
-  const lowEntropyBrands = [];
-  const fullVersionList = [];
-  if (browserName === "Edge") {
-    const brands = [
-      { brand: greaseBrand, major: greaseMajor, full: greaseFull },
-      { brand: "Chromium", major: String(majorVersion), full: fullVersion },
-      { brand: "Microsoft Edge", major: String(majorVersion), full: fullVersion }
-    ];
-    shuffleArray(brands, prng);
-    for (const b of brands) {
-      lowEntropyBrands.push({ brand: b.brand, version: b.major });
-      fullVersionList.push({ brand: b.brand, version: b.full });
-    }
-  } else {
-    const brands = [
-      { brand: greaseBrand, major: greaseMajor, full: greaseFull },
-      { brand: "Chromium", major: String(majorVersion), full: fullVersion },
-      { brand: "Google Chrome", major: String(majorVersion), full: fullVersion }
-    ];
-    shuffleArray(brands, prng);
-    for (const b of brands) {
-      lowEntropyBrands.push({ brand: b.brand, version: b.major });
-      fullVersionList.push({ brand: b.brand, version: b.full });
-    }
-  }
-  return { lowEntropyBrands, fullVersionList };
-}
-function formatStructuredBrandList(brands) {
-  return brands.map((b) => `"${b.brand}";v="${b.version}"`).join(", ");
-}
-function parseStructuredBrandList(headerValue) {
-  if (!headerValue) return [];
-  const brands = [];
-  const regex = /"([^"]+)";v="([^"]+)"/g;
-  let match;
-  while ((match = regex.exec(headerValue)) !== null) {
-    if (match[1] && match[2]) {
-      brands.push({ brand: match[1], version: match[2] });
-    }
-  }
-  return brands;
-}
-function generateUserAgentClientHints(options) {
-  const { browserName, fullVersion, majorVersion, os, prng = Math.random } = options;
-  const { lowEntropyBrands, fullVersionList } = generateBrandVersions(
-    browserName,
-    majorVersion,
-    fullVersion,
-    prng
-  );
-  const isWindows = os.platform === "Windows";
-  const architecture = os.architecture;
-  const bitness = "64";
-  const model = "";
-  const mobile = false;
-  const secChUa = formatStructuredBrandList(lowEntropyBrands);
-  const secChUaFullVersionList = formatStructuredBrandList(fullVersionList);
-  const secChUaMobile = "?0";
-  const secChUaPlatform = `"${os.platform}"`;
-  const secChUaPlatformVersion = `"${os.version}"`;
-  const secChUaArch = `"${architecture}"`;
-  const secChUaBitness = `"${bitness}"`;
-  const secChUaModel = `"${model}"`;
-  const headers = {
-    "sec-ch-ua": secChUa,
-    "sec-ch-ua-mobile": secChUaMobile,
-    "sec-ch-ua-platform": secChUaPlatform,
-    "sec-ch-ua-platform-version": secChUaPlatformVersion,
-    "sec-ch-ua-arch": secChUaArch,
-    "sec-ch-ua-bitness": secChUaBitness,
-    "sec-ch-ua-model": secChUaModel,
-    "sec-ch-ua-full-version-list": secChUaFullVersionList
-  };
-  if (isWindows) {
-    headers["sec-ch-ua-wow64"] = "?0";
-  }
-  return {
-    brands: lowEntropyBrands,
-    mobile,
-    platform: os.platform,
-    platformVersion: os.version,
-    architecture,
-    bitness,
-    model,
-    fullVersionList,
-    wow64: isWindows ? false : void 0,
-    headers
-  };
-}
-function shuffleArray(arr, prng) {
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(prng() * (i + 1));
-    const temp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = temp;
-  }
-}
-
-const DEFAULT_COUNTRY = "US";
-const DEFAULT_LOCALE = "en-US";
-const DEFAULT_TIMEZONE = "America/New_York";
-const DEFAULT_ACCEPT_LANGUAGE = "en-US,en;q=0.9";
-const COUNTRY_LOCALES = {
-  US: {
-    country: "US",
-    countryName: "United States",
-    primaryLocale: "en-US",
-    languages: ["en-US", "en"],
-    acceptLanguage: "en-US,en;q=0.9",
-    timezones: [
-      "America/New_York",
-      "America/Los_Angeles",
-      "America/Chicago",
-      "America/Denver",
-      "America/Phoenix",
-      "America/Anchorage",
-      "America/Honolulu",
-      "America/Detroit",
-      "America/Indiana/Indianapolis"
-    ],
-    defaultTimezone: "America/New_York",
-    currency: "USD",
-    coordinates: { latitude: 37.7749, longitude: -122.4194, accuracy: 1e3 }
-  },
-  GB: {
-    country: "GB",
-    countryName: "United Kingdom",
-    primaryLocale: "en-GB",
-    languages: ["en-GB", "en-US", "en"],
-    acceptLanguage: "en-GB,en-US;q=0.9,en;q=0.8",
-    timezones: ["Europe/London"],
-    defaultTimezone: "Europe/London",
-    currency: "GBP",
-    coordinates: { latitude: 51.5074, longitude: -0.1278, accuracy: 1e3 }
-  },
-  DE: {
-    country: "DE",
-    countryName: "Germany",
-    primaryLocale: "de-DE",
-    languages: ["de-DE", "de", "en-US", "en"],
-    acceptLanguage: "de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Berlin"],
-    defaultTimezone: "Europe/Berlin",
-    currency: "EUR",
-    coordinates: { latitude: 52.52, longitude: 13.405, accuracy: 1e3 }
-  },
-  FR: {
-    country: "FR",
-    countryName: "France",
-    primaryLocale: "fr-FR",
-    languages: ["fr-FR", "fr", "en-US", "en"],
-    acceptLanguage: "fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Paris"],
-    defaultTimezone: "Europe/Paris",
-    currency: "EUR",
-    coordinates: { latitude: 48.8566, longitude: 2.3522, accuracy: 1e3 }
-  },
-  JP: {
-    country: "JP",
-    countryName: "Japan",
-    primaryLocale: "ja-JP",
-    languages: ["ja-JP", "ja", "en-US"],
-    acceptLanguage: "ja-JP,ja;q=0.9,en-US;q=0.8",
-    timezones: ["Asia/Tokyo"],
-    defaultTimezone: "Asia/Tokyo",
-    currency: "JPY",
-    coordinates: { latitude: 35.6762, longitude: 139.6503, accuracy: 1e3 }
-  },
-  SG: {
-    country: "SG",
-    countryName: "Singapore",
-    primaryLocale: "en-SG",
-    languages: ["en-SG", "en-US", "en", "zh-CN"],
-    acceptLanguage: "en-SG,en-US;q=0.9,en;q=0.8,zh-CN;q=0.7",
-    timezones: ["Asia/Singapore"],
-    defaultTimezone: "Asia/Singapore",
-    currency: "SGD",
-    coordinates: { latitude: 1.3521, longitude: 103.8198, accuracy: 1e3 }
-  },
-  HK: {
-    country: "HK",
-    countryName: "Hong Kong",
-    primaryLocale: "zh-HK",
-    languages: ["zh-HK", "zh-TW", "zh", "en-US"],
-    acceptLanguage: "zh-HK,zh-TW;q=0.9,zh;q=0.8,en-US;q=0.7",
-    timezones: ["Asia/Hong_Kong"],
-    defaultTimezone: "Asia/Hong_Kong",
-    currency: "HKD",
-    coordinates: { latitude: 22.3193, longitude: 114.1694, accuracy: 1e3 }
-  },
-  TW: {
-    country: "TW",
-    countryName: "Taiwan",
-    primaryLocale: "zh-TW",
-    languages: ["zh-TW", "zh", "en-US"],
-    acceptLanguage: "zh-TW,zh;q=0.9,en-US;q=0.8",
-    timezones: ["Asia/Taipei"],
-    defaultTimezone: "Asia/Taipei",
-    currency: "TWD",
-    coordinates: { latitude: 25.033, longitude: 121.5654, accuracy: 1e3 }
-  },
-  CN: {
-    country: "CN",
-    countryName: "China",
-    primaryLocale: "zh-CN",
-    languages: ["zh-CN", "zh", "en-US", "en"],
-    acceptLanguage: "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Asia/Shanghai", "Asia/Urumqi"],
-    defaultTimezone: "Asia/Shanghai",
-    currency: "CNY",
-    coordinates: { latitude: 31.2304, longitude: 121.4737, accuracy: 1e3 }
-  },
-  KR: {
-    country: "KR",
-    countryName: "South Korea",
-    primaryLocale: "ko-KR",
-    languages: ["ko-KR", "ko", "en-US", "en"],
-    acceptLanguage: "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Asia/Seoul"],
-    defaultTimezone: "Asia/Seoul",
-    currency: "KRW",
-    coordinates: { latitude: 37.5665, longitude: 126.978, accuracy: 1e3 }
-  },
-  AU: {
-    country: "AU",
-    countryName: "Australia",
-    primaryLocale: "en-AU",
-    languages: ["en-AU", "en-GB", "en-US", "en"],
-    acceptLanguage: "en-AU,en-GB;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: [
-      "Australia/Sydney",
-      "Australia/Melbourne",
-      "Australia/Brisbane",
-      "Australia/Perth",
-      "Australia/Adelaide",
-      "Australia/Hobart",
-      "Australia/Darwin"
-    ],
-    defaultTimezone: "Australia/Sydney",
-    currency: "AUD",
-    coordinates: { latitude: -33.8688, longitude: 151.2093, accuracy: 1e3 }
-  },
-  CA: {
-    country: "CA",
-    countryName: "Canada",
-    primaryLocale: "en-CA",
-    languages: ["en-CA", "en-US", "en", "fr-CA"],
-    acceptLanguage: "en-CA,en-US;q=0.9,en;q=0.8,fr-CA;q=0.7",
-    timezones: [
-      "America/Toronto",
-      "America/Vancouver",
-      "America/Montreal",
-      "America/Edmonton",
-      "America/Winnipeg",
-      "America/Halifax",
-      "America/St_Johns"
-    ],
-    defaultTimezone: "America/Toronto",
-    currency: "CAD",
-    coordinates: { latitude: 43.6532, longitude: -79.3832, accuracy: 1e3 }
-  },
-  NL: {
-    country: "NL",
-    countryName: "Netherlands",
-    primaryLocale: "nl-NL",
-    languages: ["nl-NL", "nl", "en-US", "en"],
-    acceptLanguage: "nl-NL,nl;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Amsterdam"],
-    defaultTimezone: "Europe/Amsterdam",
-    currency: "EUR",
-    coordinates: { latitude: 52.3676, longitude: 4.9041, accuracy: 1e3 }
-  },
-  IN: {
-    country: "IN",
-    countryName: "India",
-    primaryLocale: "en-IN",
-    languages: ["en-IN", "en-GB", "en-US", "en", "hi"],
-    acceptLanguage: "en-IN,en-GB;q=0.9,en-US;q=0.8,en;q=0.7,hi;q=0.6",
-    timezones: ["Asia/Kolkata"],
-    defaultTimezone: "Asia/Kolkata",
-    currency: "INR",
-    coordinates: { latitude: 28.6139, longitude: 77.209, accuracy: 1e3 }
-  },
-  BR: {
-    country: "BR",
-    countryName: "Brazil",
-    primaryLocale: "pt-BR",
-    languages: ["pt-BR", "pt", "en-US", "en"],
-    acceptLanguage: "pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: [
-      "America/Sao_Paulo",
-      "America/Fortaleza",
-      "America/Manaus",
-      "America/Recife",
-      "America/Belem",
-      "America/Cuiaba"
-    ],
-    defaultTimezone: "America/Sao_Paulo",
-    currency: "BRL",
-    coordinates: { latitude: -23.5505, longitude: -46.6333, accuracy: 1e3 }
-  },
-  IT: {
-    country: "IT",
-    countryName: "Italy",
-    primaryLocale: "it-IT",
-    languages: ["it-IT", "it", "en-US", "en"],
-    acceptLanguage: "it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Rome"],
-    defaultTimezone: "Europe/Rome",
-    currency: "EUR",
-    coordinates: { latitude: 41.9028, longitude: 12.4964, accuracy: 1e3 }
-  },
-  ES: {
-    country: "ES",
-    countryName: "Spain",
-    primaryLocale: "es-ES",
-    languages: ["es-ES", "es", "en-US", "en"],
-    acceptLanguage: "es-ES,es;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Madrid", "Atlantic/Canary"],
-    defaultTimezone: "Europe/Madrid",
-    currency: "EUR",
-    coordinates: { latitude: 40.4168, longitude: -3.7038, accuracy: 1e3 }
-  },
-  RU: {
-    country: "RU",
-    countryName: "Russia",
-    primaryLocale: "ru-RU",
-    languages: ["ru-RU", "ru", "en-US", "en"],
-    acceptLanguage: "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Moscow", "Europe/Samara", "Asia/Yekaterinburg", "Asia/Novosibirsk", "Asia/Vladivostok"],
-    defaultTimezone: "Europe/Moscow",
-    currency: "RUB",
-    coordinates: { latitude: 55.7558, longitude: 37.6173, accuracy: 1e3 }
-  },
-  MX: {
-    country: "MX",
-    countryName: "Mexico",
-    primaryLocale: "es-MX",
-    languages: ["es-MX", "es", "en-US", "en"],
-    acceptLanguage: "es-MX,es;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["America/Mexico_City", "America/Cancun", "America/Monterrey", "America/Tijuana"],
-    defaultTimezone: "America/Mexico_City",
-    currency: "MXN",
-    coordinates: { latitude: 19.4326, longitude: -99.1332, accuracy: 1e3 }
-  },
-  ID: {
-    country: "ID",
-    countryName: "Indonesia",
-    primaryLocale: "id-ID",
-    languages: ["id-ID", "id", "en-US", "en"],
-    acceptLanguage: "id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Asia/Jakarta", "Asia/Makassar", "Asia/Jayapura"],
-    defaultTimezone: "Asia/Jakarta",
-    currency: "IDR",
-    coordinates: { latitude: -6.2088, longitude: 106.8456, accuracy: 1e3 }
-  },
-  MY: {
-    country: "MY",
-    countryName: "Malaysia",
-    primaryLocale: "ms-MY",
-    languages: ["ms-MY", "ms", "en-US", "en"],
-    acceptLanguage: "ms-MY,ms;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Asia/Kuala_Lumpur", "Asia/Kuching"],
-    defaultTimezone: "Asia/Kuala_Lumpur",
-    currency: "MYR",
-    coordinates: { latitude: 3.139, longitude: 101.6869, accuracy: 1e3 }
-  },
-  TH: {
-    country: "TH",
-    countryName: "Thailand",
-    primaryLocale: "th-TH",
-    languages: ["th-TH", "th", "en-US", "en"],
-    acceptLanguage: "th-TH,th;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Asia/Bangkok"],
-    defaultTimezone: "Asia/Bangkok",
-    currency: "THB",
-    coordinates: { latitude: 13.7563, longitude: 100.5018, accuracy: 1e3 }
-  },
-  VN: {
-    country: "VN",
-    countryName: "Vietnam",
-    primaryLocale: "vi-VN",
-    languages: ["vi-VN", "vi", "en-US", "en"],
-    acceptLanguage: "vi-VN,vi;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Asia/Ho_Chi_Minh"],
-    defaultTimezone: "Asia/Ho_Chi_Minh",
-    currency: "VND",
-    coordinates: { latitude: 10.8231, longitude: 106.6297, accuracy: 1e3 }
-  },
-  PH: {
-    country: "PH",
-    countryName: "Philippines",
-    primaryLocale: "en-PH",
-    languages: ["en-PH", "en-US", "en", "fil"],
-    acceptLanguage: "en-PH,en-US;q=0.9,en;q=0.8,fil;q=0.7",
-    timezones: ["Asia/Manila"],
-    defaultTimezone: "Asia/Manila",
-    currency: "PHP",
-    coordinates: { latitude: 14.5995, longitude: 120.9842, accuracy: 1e3 }
-  },
-  SE: {
-    country: "SE",
-    countryName: "Sweden",
-    primaryLocale: "sv-SE",
-    languages: ["sv-SE", "sv", "en-US", "en"],
-    acceptLanguage: "sv-SE,sv;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Stockholm"],
-    defaultTimezone: "Europe/Stockholm",
-    currency: "SEK",
-    coordinates: { latitude: 59.3293, longitude: 18.0686, accuracy: 1e3 }
-  },
-  NO: {
-    country: "NO",
-    countryName: "Norway",
-    primaryLocale: "nb-NO",
-    languages: ["nb-NO", "nb", "nn", "en-US", "en"],
-    acceptLanguage: "nb-NO,nb;q=0.9,nn;q=0.8,en-US;q=0.7,en;q=0.6",
-    timezones: ["Europe/Oslo"],
-    defaultTimezone: "Europe/Oslo",
-    currency: "NOK",
-    coordinates: { latitude: 59.9139, longitude: 10.7522, accuracy: 1e3 }
-  },
-  DK: {
-    country: "DK",
-    countryName: "Denmark",
-    primaryLocale: "da-DK",
-    languages: ["da-DK", "da", "en-US", "en"],
-    acceptLanguage: "da-DK,da;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Copenhagen"],
-    defaultTimezone: "Europe/Copenhagen",
-    currency: "DKK",
-    coordinates: { latitude: 55.6761, longitude: 12.5683, accuracy: 1e3 }
-  },
-  FI: {
-    country: "FI",
-    countryName: "Finland",
-    primaryLocale: "fi-FI",
-    languages: ["fi-FI", "fi", "sv-FI", "en-US", "en"],
-    acceptLanguage: "fi-FI,fi;q=0.9,sv-FI;q=0.8,en-US;q=0.7,en;q=0.6",
-    timezones: ["Europe/Helsinki"],
-    defaultTimezone: "Europe/Helsinki",
-    currency: "EUR",
-    coordinates: { latitude: 60.1699, longitude: 24.9384, accuracy: 1e3 }
-  },
-  PL: {
-    country: "PL",
-    countryName: "Poland",
-    primaryLocale: "pl-PL",
-    languages: ["pl-PL", "pl", "en-US", "en"],
-    acceptLanguage: "pl-PL,pl;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Warsaw"],
-    defaultTimezone: "Europe/Warsaw",
-    currency: "PLN",
-    coordinates: { latitude: 52.2297, longitude: 21.0122, accuracy: 1e3 }
-  },
-  CH: {
-    country: "CH",
-    countryName: "Switzerland",
-    primaryLocale: "de-CH",
-    languages: ["de-CH", "fr-CH", "it-CH", "en-US", "en"],
-    acceptLanguage: "de-CH,fr-CH;q=0.9,it-CH;q=0.8,en-US;q=0.7,en;q=0.6",
-    timezones: ["Europe/Zurich"],
-    defaultTimezone: "Europe/Zurich",
-    currency: "CHF",
-    coordinates: { latitude: 47.3769, longitude: 8.5417, accuracy: 1e3 }
-  },
-  AT: {
-    country: "AT",
-    countryName: "Austria",
-    primaryLocale: "de-AT",
-    languages: ["de-AT", "de", "en-US", "en"],
-    acceptLanguage: "de-AT,de;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Vienna"],
-    defaultTimezone: "Europe/Vienna",
-    currency: "EUR",
-    coordinates: { latitude: 48.2082, longitude: 16.3738, accuracy: 1e3 }
-  },
-  BE: {
-    country: "BE",
-    countryName: "Belgium",
-    primaryLocale: "nl-BE",
-    languages: ["nl-BE", "fr-BE", "en-US", "en"],
-    acceptLanguage: "nl-BE,fr-BE;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Brussels"],
-    defaultTimezone: "Europe/Brussels",
-    currency: "EUR",
-    coordinates: { latitude: 50.8503, longitude: 4.3517, accuracy: 1e3 }
-  },
-  IE: {
-    country: "IE",
-    countryName: "Ireland",
-    primaryLocale: "en-IE",
-    languages: ["en-IE", "en-GB", "en-US", "en", "ga"],
-    acceptLanguage: "en-IE,en-GB;q=0.9,en-US;q=0.8,en;q=0.7,ga;q=0.6",
-    timezones: ["Europe/Dublin"],
-    defaultTimezone: "Europe/Dublin",
-    currency: "EUR",
-    coordinates: { latitude: 53.3498, longitude: -6.2603, accuracy: 1e3 }
-  },
-  NZ: {
-    country: "NZ",
-    countryName: "New Zealand",
-    primaryLocale: "en-NZ",
-    languages: ["en-NZ", "en-GB", "en-US", "en"],
-    acceptLanguage: "en-NZ,en-GB;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Pacific/Auckland", "Pacific/Chatham"],
-    defaultTimezone: "Pacific/Auckland",
-    currency: "NZD",
-    coordinates: { latitude: -36.8485, longitude: 174.7633, accuracy: 1e3 }
-  },
-  TR: {
-    country: "TR",
-    countryName: "Turkey",
-    primaryLocale: "tr-TR",
-    languages: ["tr-TR", "tr", "en-US", "en"],
-    acceptLanguage: "tr-TR,tr;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Istanbul"],
-    defaultTimezone: "Europe/Istanbul",
-    currency: "TRY",
-    coordinates: { latitude: 41.0082, longitude: 28.9784, accuracy: 1e3 }
-  },
-  SA: {
-    country: "SA",
-    countryName: "Saudi Arabia",
-    primaryLocale: "ar-SA",
-    languages: ["ar-SA", "ar", "en-US", "en"],
-    acceptLanguage: "ar-SA,ar;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Asia/Riyadh"],
-    defaultTimezone: "Asia/Riyadh",
-    currency: "SAR",
-    coordinates: { latitude: 24.7136, longitude: 46.6753, accuracy: 1e3 }
-  },
-  AE: {
-    country: "AE",
-    countryName: "United Arab Emirates",
-    primaryLocale: "ar-AE",
-    languages: ["ar-AE", "ar", "en-US", "en"],
-    acceptLanguage: "ar-AE,ar;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Asia/Dubai"],
-    defaultTimezone: "Asia/Dubai",
-    currency: "AED",
-    coordinates: { latitude: 25.2048, longitude: 55.2708, accuracy: 1e3 }
-  },
-  ZA: {
-    country: "ZA",
-    countryName: "South Africa",
-    primaryLocale: "en-ZA",
-    languages: ["en-ZA", "en-GB", "en-US", "en", "af"],
-    acceptLanguage: "en-ZA,en-GB;q=0.9,en-US;q=0.8,en;q=0.7,af;q=0.6",
-    timezones: ["Africa/Johannesburg"],
-    defaultTimezone: "Africa/Johannesburg",
-    currency: "ZAR",
-    coordinates: { latitude: -26.2041, longitude: 28.0473, accuracy: 1e3 }
-  },
-  AR: {
-    country: "AR",
-    countryName: "Argentina",
-    primaryLocale: "es-AR",
-    languages: ["es-AR", "es", "en-US", "en"],
-    acceptLanguage: "es-AR,es;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["America/Argentina/Buenos_Aires", "America/Argentina/Cordoba"],
-    defaultTimezone: "America/Argentina/Buenos_Aires",
-    currency: "ARS",
-    coordinates: { latitude: -34.6037, longitude: -58.3816, accuracy: 1e3 }
-  },
-  CL: {
-    country: "CL",
-    countryName: "Chile",
-    primaryLocale: "es-CL",
-    languages: ["es-CL", "es", "en-US", "en"],
-    acceptLanguage: "es-CL,es;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["America/Santiago", "Pacific/Easter"],
-    defaultTimezone: "America/Santiago",
-    currency: "CLP",
-    coordinates: { latitude: -33.4489, longitude: -70.6693, accuracy: 1e3 }
-  },
-  CO: {
-    country: "CO",
-    countryName: "Colombia",
-    primaryLocale: "es-CO",
-    languages: ["es-CO", "es", "en-US", "en"],
-    acceptLanguage: "es-CO,es;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["America/Bogota"],
-    defaultTimezone: "America/Bogota",
-    currency: "COP",
-    coordinates: { latitude: 4.711, longitude: -74.0721, accuracy: 1e3 }
-  },
-  IL: {
-    country: "IL",
-    countryName: "Israel",
-    primaryLocale: "he-IL",
-    languages: ["he-IL", "he", "en-US", "en"],
-    acceptLanguage: "he-IL,he;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Asia/Jerusalem"],
-    defaultTimezone: "Asia/Jerusalem",
-    currency: "ILS",
-    coordinates: { latitude: 31.7683, longitude: 35.2137, accuracy: 1e3 }
-  },
-  UA: {
-    country: "UA",
-    countryName: "Ukraine",
-    primaryLocale: "uk-UA",
-    languages: ["uk-UA", "uk", "en-US", "en"],
-    acceptLanguage: "uk-UA,uk;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Kyiv"],
-    defaultTimezone: "Europe/Kyiv",
-    currency: "UAH",
-    coordinates: { latitude: 50.4501, longitude: 30.5234, accuracy: 1e3 }
-  },
-  PT: {
-    country: "PT",
-    countryName: "Portugal",
-    primaryLocale: "pt-PT",
-    languages: ["pt-PT", "pt", "en-US", "en"],
-    acceptLanguage: "pt-PT,pt;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Lisbon", "Atlantic/Madeira", "Atlantic/Azores"],
-    defaultTimezone: "Europe/Lisbon",
-    currency: "EUR",
-    coordinates: { latitude: 38.7223, longitude: -9.1393, accuracy: 1e3 }
-  },
-  CZ: {
-    country: "CZ",
-    countryName: "Czech Republic",
-    primaryLocale: "cs-CZ",
-    languages: ["cs-CZ", "cs", "en-US", "en"],
-    acceptLanguage: "cs-CZ,cs;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Prague"],
-    defaultTimezone: "Europe/Prague",
-    currency: "CZK",
-    coordinates: { latitude: 50.0755, longitude: 14.4378, accuracy: 1e3 }
-  },
-  RO: {
-    country: "RO",
-    countryName: "Romania",
-    primaryLocale: "ro-RO",
-    languages: ["ro-RO", "ro", "en-US", "en"],
-    acceptLanguage: "ro-RO,ro;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Bucharest"],
-    defaultTimezone: "Europe/Bucharest",
-    currency: "RON",
-    coordinates: { latitude: 44.4268, longitude: 26.1025, accuracy: 1e3 }
-  },
-  GR: {
-    country: "GR",
-    countryName: "Greece",
-    primaryLocale: "el-GR",
-    languages: ["el-GR", "el", "en-US", "en"],
-    acceptLanguage: "el-GR,el;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Athens"],
-    defaultTimezone: "Europe/Athens",
-    currency: "EUR",
-    coordinates: { latitude: 37.9838, longitude: 23.7275, accuracy: 1e3 }
-  },
-  HU: {
-    country: "HU",
-    countryName: "Hungary",
-    primaryLocale: "hu-HU",
-    languages: ["hu-HU", "hu", "en-US", "en"],
-    acceptLanguage: "hu-HU,hu;q=0.9,en-US;q=0.8,en;q=0.7",
-    timezones: ["Europe/Budapest"],
-    defaultTimezone: "Europe/Budapest",
-    currency: "HUF",
-    coordinates: { latitude: 47.4979, longitude: 19.0402, accuracy: 1e3 }
-  }
-};
-function getCountryConfig(countryCode) {
-  if (!countryCode) {
-    return COUNTRY_LOCALES[DEFAULT_COUNTRY];
-  }
-  const normalized = countryCode.trim().toUpperCase();
-  return COUNTRY_LOCALES[normalized] || COUNTRY_LOCALES[DEFAULT_COUNTRY];
-}
-function hasCountryConfig(countryCode) {
-  if (!countryCode) return false;
-  return Object.prototype.hasOwnProperty.call(COUNTRY_LOCALES, countryCode.trim().toUpperCase());
-}
-function getAllSupportedCountries() {
-  return Object.keys(COUNTRY_LOCALES);
-}
-function formatAcceptLanguage(languages) {
-  if (!languages || languages.length === 0) {
-    return DEFAULT_ACCEPT_LANGUAGE;
-  }
-  const uniqueLangs = [];
-  for (const lang of languages) {
-    const trimmed = lang.trim();
-    if (trimmed && !uniqueLangs.includes(trimmed)) {
-      uniqueLangs.push(trimmed);
-    }
-  }
-  if (uniqueLangs.length === 0) {
-    return DEFAULT_ACCEPT_LANGUAGE;
-  }
-  return uniqueLangs.map((lang, index) => {
-    if (index === 0) return lang;
-    const weight = Math.max(0.1, Number((1 - index * 0.1).toFixed(1)));
-    return `${lang};q=${weight}`;
-  }).join(",");
-}
-function parseAcceptLanguage(header) {
-  if (!header || typeof header !== "string") return [];
-  return header.split(",").map((part) => {
-    const [localePart, ...params] = part.trim().split(";");
-    const locale = localePart.trim();
-    let q = 1;
-    for (const param of params) {
-      const [key, val] = param.trim().split("=");
-      if (key && key.trim() === "q" && val) {
-        const parsed = parseFloat(val.trim());
-        if (!isNaN(parsed)) {
-          q = parsed;
-        }
-      }
-    }
-    return { locale, q };
-  }).filter((item) => item.locale.length > 0).sort((a, b) => b.q - a.q);
-}
-
-const TIMEZONE_TO_COUNTRY = {
-  // United States
-  "America/New_York": "US",
-  "America/Los_Angeles": "US",
-  "America/Chicago": "US",
-  "America/Denver": "US",
-  "America/Phoenix": "US",
-  "America/Anchorage": "US",
-  "America/Honolulu": "US",
-  "America/Detroit": "US",
-  "America/Indiana/Indianapolis": "US",
-  "America/Boise": "US",
-  "America/Juneau": "US",
-  "America/Adak": "US",
-  "America/Nome": "US",
-  "America/Sitka": "US",
-  "America/Yakutat": "US",
-  "America/Metlakatla": "US",
-  "America/Menominee": "US",
-  "America/Kentucky/Louisville": "US",
-  "America/Kentucky/Monticello": "US",
-  "America/Indiana/Marengo": "US",
-  "America/Indiana/Vincennes": "US",
-  "America/Indiana/Tell_City": "US",
-  "America/Indiana/Petersburg": "US",
-  "America/Indiana/Knox": "US",
-  "America/Indiana/Winamac": "US",
-  "America/Indiana/Vevay": "US",
-  "America/North_Dakota/Center": "US",
-  "America/North_Dakota/New_Salem": "US",
-  "America/North_Dakota/Beulah": "US",
-  // United Kingdom
-  "Europe/London": "GB",
-  // Germany
-  "Europe/Berlin": "DE",
-  "Europe/Busingen": "DE",
-  // France
-  "Europe/Paris": "FR",
-  // Japan
-  "Asia/Tokyo": "JP",
-  // Singapore
-  "Asia/Singapore": "SG",
-  // Hong Kong
-  "Asia/Hong_Kong": "HK",
-  // Taiwan
-  "Asia/Taipei": "TW",
-  // China
-  "Asia/Shanghai": "CN",
-  "Asia/Urumqi": "CN",
-  "Asia/Chongqing": "CN",
-  "Asia/Harbin": "CN",
-  "Asia/Kashgar": "CN",
-  // South Korea
-  "Asia/Seoul": "KR",
-  // Australia
-  "Australia/Sydney": "AU",
-  "Australia/Melbourne": "AU",
-  "Australia/Brisbane": "AU",
-  "Australia/Perth": "AU",
-  "Australia/Adelaide": "AU",
-  "Australia/Hobart": "AU",
-  "Australia/Darwin": "AU",
-  "Australia/Broken_Hill": "AU",
-  "Australia/Lord_Howe": "AU",
-  "Australia/Lindeman": "AU",
-  "Australia/Eucla": "AU",
-  // Canada
-  "America/Toronto": "CA",
-  "America/Vancouver": "CA",
-  "America/Montreal": "CA",
-  "America/Edmonton": "CA",
-  "America/Winnipeg": "CA",
-  "America/Halifax": "CA",
-  "America/St_Johns": "CA",
-  "America/Regina": "CA",
-  "America/Calgary": "CA",
-  "America/Whitehorse": "CA",
-  "America/Dawson": "CA",
-  "America/Yellowknife": "CA",
-  "America/Iqaluit": "CA",
-  // Netherlands
-  "Europe/Amsterdam": "NL",
-  // India
-  "Asia/Kolkata": "IN",
-  "Asia/Calcutta": "IN",
-  // Brazil
-  "America/Sao_Paulo": "BR",
-  "America/Fortaleza": "BR",
-  "America/Manaus": "BR",
-  "America/Recife": "BR",
-  "America/Belem": "BR",
-  "America/Cuiaba": "BR",
-  "America/Porto_Velho": "BR",
-  "America/Boa_Vista": "BR",
-  "America/Rio_Branco": "BR",
-  "America/Campo_Grande": "BR",
-  "America/Maceio": "BR",
-  "America/Araguaina": "BR",
-  "America/Santarem": "BR",
-  "America/Noronha": "BR",
-  // Italy
-  "Europe/Rome": "IT",
-  // Spain
-  "Europe/Madrid": "ES",
-  "Atlantic/Canary": "ES",
-  "Africa/Ceuta": "ES",
-  // Russia
-  "Europe/Moscow": "RU",
-  "Europe/Samara": "RU",
-  "Europe/Kaliningrad": "RU",
-  "Asia/Yekaterinburg": "RU",
-  "Asia/Novosibirsk": "RU",
-  "Asia/Krasnoyarsk": "RU",
-  "Asia/Irkutsk": "RU",
-  "Asia/Yakutsk": "RU",
-  "Asia/Vladivostok": "RU",
-  "Asia/Magadan": "RU",
-  "Asia/Kamchatka": "RU",
-  // Mexico
-  "America/Mexico_City": "MX",
-  "America/Cancun": "MX",
-  "America/Monterrey": "MX",
-  "America/Tijuana": "MX",
-  "America/Hermosillo": "MX",
-  "America/Chihuahua": "MX",
-  "America/Mazatlan": "MX",
-  "America/Merida": "MX",
-  // Indonesia
-  "Asia/Jakarta": "ID",
-  "Asia/Makassar": "ID",
-  "Asia/Jayapura": "ID",
-  "Asia/Pontianak": "ID",
-  // Malaysia
-  "Asia/Kuala_Lumpur": "MY",
-  "Asia/Kuching": "MY",
-  // Thailand
-  "Asia/Bangkok": "TH",
-  // Vietnam
-  "Asia/Ho_Chi_Minh": "VN",
-  // Philippines
-  "Asia/Manila": "PH",
-  // Sweden
-  "Europe/Stockholm": "SE",
-  // Norway
-  "Europe/Oslo": "NO",
-  // Denmark
-  "Europe/Copenhagen": "DK",
-  // Finland
-  "Europe/Helsinki": "FI",
-  // Poland
-  "Europe/Warsaw": "PL",
-  // Switzerland
-  "Europe/Zurich": "CH",
-  // Austria
-  "Europe/Vienna": "AT",
-  // Belgium
-  "Europe/Brussels": "BE",
-  // Ireland
-  "Europe/Dublin": "IE",
-  // New Zealand
-  "Pacific/Auckland": "NZ",
-  "Pacific/Chatham": "NZ",
-  // Turkey
-  "Europe/Istanbul": "TR",
-  // Saudi Arabia
-  "Asia/Riyadh": "SA",
-  // United Arab Emirates
-  "Asia/Dubai": "AE",
-  // South Africa
-  "Africa/Johannesburg": "ZA",
-  // Argentina
-  "America/Argentina/Buenos_Aires": "AR",
-  "America/Argentina/Cordoba": "AR",
-  "America/Argentina/Salta": "AR",
-  "America/Argentina/Jujuy": "AR",
-  "America/Argentina/Tucuman": "AR",
-  "America/Argentina/Catamarca": "AR",
-  "America/Argentina/La_Rioja": "AR",
-  "America/Argentina/San_Juan": "AR",
-  "America/Argentina/Mendoza": "AR",
-  "America/Argentina/San_Luis": "AR",
-  "America/Argentina/Rio_Gallegos": "AR",
-  "America/Argentina/Ushuaia": "AR",
-  // Chile
-  "America/Santiago": "CL",
-  "America/Punta_Arenas": "CL",
-  "Pacific/Easter": "CL",
-  // Colombia
-  "America/Bogota": "CO",
-  // Israel
-  "Asia/Jerusalem": "IL",
-  // Ukraine
-  "Europe/Kyiv": "UA",
-  // Portugal
-  "Europe/Lisbon": "PT",
-  "Atlantic/Madeira": "PT",
-  "Atlantic/Azores": "PT",
-  // Czech Republic
-  "Europe/Prague": "CZ",
-  // Romania
-  "Europe/Bucharest": "RO",
-  // Greece
-  "Europe/Athens": "GR",
-  // Hungary
-  "Europe/Budapest": "HU"
-};
-function isValidTimezone(timezone) {
-  if (!timezone || typeof timezone !== "string") {
-    return false;
-  }
-  const trimmed = timezone.trim();
-  if (trimmed.length === 0) {
-    return false;
-  }
-  if (TIMEZONE_TO_COUNTRY[trimmed]) {
-    return true;
-  }
-  try {
-    Intl.DateTimeFormat(void 0, { timeZone: trimmed });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getTimezonesForCountry(countryCode) {
-  if (!countryCode) return [DEFAULT_TIMEZONE];
-  const normalized = countryCode.trim().toUpperCase();
-  const config = COUNTRY_LOCALES[normalized];
-  if (config && config.timezones && config.timezones.length > 0) {
-    return [...config.timezones];
-  }
-  const matched = Object.entries(TIMEZONE_TO_COUNTRY).filter(([_, cc]) => cc === normalized).map(([tz]) => tz);
-  return matched.length > 0 ? matched : [DEFAULT_TIMEZONE];
-}
-function getCountryForTimezone(timezone) {
-  if (!timezone) return void 0;
-  const trimmed = timezone.trim();
-  return TIMEZONE_TO_COUNTRY[trimmed];
-}
-function getDefaultTimezoneForCountry(countryCode) {
-  if (!countryCode) return DEFAULT_TIMEZONE;
-  const normalized = countryCode.trim().toUpperCase();
-  const config = COUNTRY_LOCALES[normalized];
-  if (config && config.defaultTimezone) {
-    return config.defaultTimezone;
-  }
-  const countryTzs = getTimezonesForCountry(normalized);
-  return countryTzs[0] || DEFAULT_TIMEZONE;
-}
-function isTimezoneAlignedWithCountry(timezone, countryCode) {
-  if (!timezone || !countryCode) return false;
-  const normalized = countryCode.trim().toUpperCase();
-  const mappedCountry = getCountryForTimezone(timezone);
-  if (mappedCountry === normalized) {
-    return true;
-  }
-  const countryTzs = getTimezonesForCountry(normalized);
-  return countryTzs.includes(timezone.trim());
-}
-function getTimezoneOffsetMinutes(timezone, date = /* @__PURE__ */ new Date()) {
-  if (!timezone || !isValidTimezone(timezone)) {
-    return 0;
-  }
-  try {
-    const utcDate = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
-    const tzDate = new Date(date.toLocaleString("en-US", { timeZone: timezone }));
-    return Math.round((tzDate.getTime() - utcDate.getTime()) / 6e4);
-  } catch {
-    return 0;
-  }
-}
-function listAllTimezones() {
-  return Object.keys(TIMEZONE_TO_COUNTRY);
-}
-
-const ALPHA3_TO_ALPHA2 = {
-  USA: "US",
-  GBR: "GB",
-  DEU: "DE",
-  FRA: "FR",
-  JPN: "JP",
-  SGP: "SG",
-  HKG: "HK",
-  TWN: "TW",
-  CHN: "CN",
-  KOR: "KR",
-  AUS: "AU",
-  CAN: "CA",
-  NLD: "NL",
-  IND: "IN",
-  BRA: "BR",
-  ITA: "IT",
-  ESP: "ES",
-  RUS: "RU",
-  MEX: "MX",
-  IDN: "ID",
-  MYS: "MY",
-  THA: "TH",
-  VNM: "VN",
-  PHL: "PH",
-  SWE: "SE",
-  NOR: "NO",
-  DNK: "DK",
-  FIN: "FI",
-  POL: "PL",
-  CHE: "CH",
-  AUT: "AT",
-  BEL: "BE",
-  IRL: "IE",
-  NZL: "NZ",
-  TUR: "TR",
-  SAU: "SA",
-  ARE: "AE",
-  ZAF: "ZA",
-  ARG: "AR",
-  CHL: "CL",
-  COL: "CO",
-  ISR: "IL",
-  UKR: "UA",
-  PRT: "PT",
-  CZE: "CZ",
-  ROU: "RO",
-  GRC: "GR",
-  HUN: "HU"
-};
-const COUNTRY_NAME_TO_CODE = {
-  "united states": "US",
-  "united states of america": "US",
-  "great britain": "GB",
-  "united kingdom": "GB",
-  england: "GB",
-  uk: "GB",
-  germany: "DE",
-  deutschland: "DE",
-  france: "FR",
-  japan: "JP",
-  singapore: "SG",
-  "hong kong": "HK",
-  taiwan: "TW",
-  china: "CN",
-  "south korea": "KR",
-  korea: "KR",
-  australia: "AU",
-  canada: "CA",
-  netherlands: "NL",
-  holland: "NL",
-  india: "IN",
-  brazil: "BR",
-  brasil: "BR",
-  italy: "IT",
-  spain: "ES",
-  russia: "RU",
-  mexico: "MX",
-  indonesia: "ID",
-  malaysia: "MY",
-  thailand: "TH",
-  vietnam: "VN",
-  philippines: "PH",
-  sweden: "SE",
-  norway: "NO",
-  denmark: "DK",
-  finland: "FI",
-  poland: "PL",
-  switzerland: "CH",
-  austria: "AT",
-  belgium: "BE",
-  ireland: "IE",
-  "new zealand": "NZ",
-  turkey: "TR",
-  t\u00FCrkiye: "TR",
-  "saudi arabia": "SA",
-  "united arab emirates": "AE",
-  uae: "AE",
-  "south africa": "ZA",
-  argentina: "AR",
-  chile: "CL",
-  colombia: "CO",
-  israel: "IL",
-  ukraine: "UA",
-  portugal: "PT",
-  "czech republic": "CZ",
-  czechia: "CZ",
-  romania: "RO",
-  greece: "GR",
-  hungary: "HU"
-};
-function normalizeCountryCode(code) {
-  if (!code || typeof code !== "string") return null;
-  const trimmed = code.trim();
-  if (!trimmed) return null;
-  const upper = trimmed.toUpperCase();
-  if (upper === "UK") return "GB";
-  if (/^[A-Z]{2}$/.test(upper)) {
-    return upper;
-  }
-  if (/^[A-Z]{3}$/.test(upper) && ALPHA3_TO_ALPHA2[upper]) {
-    return ALPHA3_TO_ALPHA2[upper];
-  }
-  const lower = trimmed.toLowerCase();
-  if (COUNTRY_NAME_TO_CODE[lower]) {
-    return COUNTRY_NAME_TO_CODE[lower];
-  }
-  return null;
-}
-function extractCountryFromProxyUrl(url) {
-  if (!url || typeof url !== "string") return null;
-  const trimmed = url.trim();
-  if (!trimmed) return null;
-  let parsedUrl = null;
-  try {
-    const hasScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed);
-    parsedUrl = new URL(hasScheme ? trimmed : `http://${trimmed}`);
-  } catch {
-    parsedUrl = null;
-  }
-  if (parsedUrl) {
-    const paramNames = ["country", "country_code", "countrycode", "cc", "geo", "region"];
-    for (const param of paramNames) {
-      const val = parsedUrl.searchParams.get(param);
-      if (val) {
-        const normalized = normalizeCountryCode(val);
-        if (normalized) return normalized;
-      }
-    }
-    const localeVal = parsedUrl.searchParams.get("locale");
-    if (localeVal) {
-      const parts = localeVal.split(/[-_]/);
-      const possibleCc = parts[parts.length - 1];
-      const normalized = normalizeCountryCode(possibleCc);
-      if (normalized) return normalized;
-    }
-    if (parsedUrl.username) {
-      const username = decodeURIComponent(parsedUrl.username);
-      const userPatterns = [
-        /(?:^|[-_.:=])country[-_.:=]([a-zA-Z]{2,3})(?:[-_.:=]|$)/i,
-        /(?:^|[-_.:=])cc[-_.:=]([a-zA-Z]{2,3})(?:[-_.:=]|$)/i,
-        /(?:^|[-_.:=])geo[-_.:=]([a-zA-Z]{2,3})(?:[-_.:=]|$)/i,
-        /(?:^|[-_.:=])region[-_.:=]([a-zA-Z]{2,3})(?:[-_.:=]|$)/i,
-        /(?:^|[-_.:=])zone[-_][a-zA-Z0-9]+[-_]([a-zA-Z]{2,3})(?:[-_.:=]|$)/i
-      ];
-      for (const pattern of userPatterns) {
-        const match = username.match(pattern);
-        if (match && match[1]) {
-          const normalized = normalizeCountryCode(match[1]);
-          if (normalized) return normalized;
-        }
-      }
-    }
-    const hostname = parsedUrl.hostname.toLowerCase();
-    const hostParts = hostname.split(".");
-    if (hostParts.length >= 3) {
-      const firstPart = hostParts[0];
-      const subParts = firstPart.split(/[-_]/);
-      for (const part of subParts) {
-        if (/^[a-zA-Z]{2}$/.test(part)) {
-          const normalized = normalizeCountryCode(part);
-          if (normalized && hasCountryConfig(normalized)) {
-            return normalized;
-          }
-        }
-      }
-    }
-  }
-  const rawPatterns = [
-    /(?:^|[-_.:=?&])country[-_.:=]([a-zA-Z]{2,3})(?:[-_.:=?&]|$)/i,
-    /(?:^|[-_.:=?&])country_code=([a-zA-Z]{2,3})/i,
-    /(?:^|[-_.:=?&])cc[-_.:=]([a-zA-Z]{2,3})(?:[-_.:=?&]|$)/i,
-    /(?:^|[-_.:=?&])geo[-_.:=]([a-zA-Z]{2,3})(?:[-_.:=?&]|$)/i,
-    /(?:^|[-_.:=?&])region[-_.:=]([a-zA-Z]{2,3})(?:[-_.:=?&]|$)/i
-  ];
-  for (const pattern of rawPatterns) {
-    const match = trimmed.match(pattern);
-    if (match && match[1]) {
-      const normalized = normalizeCountryCode(match[1]);
-      if (normalized) return normalized;
-    }
-  }
-  return null;
-}
-function detectCountry(input, options) {
-  const fallback = options?.fallbackCountry && normalizeCountryCode(options.fallbackCountry) || DEFAULT_COUNTRY;
-  if (!input || typeof input !== "string") {
-    return fallback;
-  }
-  const trimmed = input.trim();
-  if (!trimmed) {
-    return fallback;
-  }
-  const directCode = normalizeCountryCode(trimmed);
-  if (directCode && hasCountryConfig(directCode)) {
-    return directCode;
-  }
-  const tzCountry = getCountryForTimezone(trimmed);
-  if (tzCountry) {
-    return tzCountry;
-  }
-  const proxyCountry = extractCountryFromProxyUrl(trimmed);
-  if (proxyCountry && hasCountryConfig(proxyCountry)) {
-    return proxyCountry;
-  }
-  return directCode || fallback;
-}
-
-function alignGeoContext(geoInput) {
-  let countryInput;
-  let proxyUrlInput;
-  let explicitTimezone;
-  let explicitLocale;
-  let explicitLanguages;
-  let explicitAcceptLanguage;
-  let fallbackCountry = DEFAULT_COUNTRY;
-  let explicitCoordinates;
-  if (typeof geoInput === "string") {
-    const trimmed = geoInput.trim();
-    if (isValidTimezone(trimmed) && trimmed.includes("/")) {
-      explicitTimezone = trimmed;
-      countryInput = trimmed;
-    } else if (trimmed.includes("://") || trimmed.includes("@") || trimmed.includes("?")) {
-      proxyUrlInput = trimmed;
-    } else {
-      countryInput = trimmed;
-    }
-  } else if (geoInput && typeof geoInput === "object") {
-    countryInput = geoInput.country;
-    proxyUrlInput = geoInput.proxyUrl;
-    explicitTimezone = geoInput.timezone;
-    explicitLocale = geoInput.locale;
-    explicitLanguages = geoInput.languages;
-    explicitAcceptLanguage = geoInput.acceptLanguage;
-    fallbackCountry = geoInput.fallbackCountry || DEFAULT_COUNTRY;
-    explicitCoordinates = geoInput.coordinates;
-  }
-  const detectedTarget = proxyUrlInput || countryInput;
-  const country = detectCountry(detectedTarget, { fallbackCountry });
-  const config = getCountryConfig(country);
-  let timezone;
-  if (explicitTimezone && isValidTimezone(explicitTimezone)) {
-    timezone = explicitTimezone;
-  } else {
-    timezone = config.defaultTimezone || getDefaultTimezoneForCountry(country);
-  }
-  const locale = explicitLocale || config.primaryLocale || DEFAULT_LOCALE;
-  const languages = explicitLanguages && explicitLanguages.length > 0 ? explicitLanguages : [...config.languages];
-  let acceptLanguage;
-  if (explicitAcceptLanguage) {
-    acceptLanguage = explicitAcceptLanguage;
-  } else if (explicitLanguages && explicitLanguages.length > 0) {
-    acceptLanguage = formatAcceptLanguage(explicitLanguages);
-  } else {
-    acceptLanguage = config.acceptLanguage || DEFAULT_ACCEPT_LANGUAGE;
-  }
-  const timezoneOffset = getTimezoneOffsetMinutes(timezone);
-  const coordinates = explicitCoordinates || config.coordinates;
-  const currency = config.currency || "USD";
-  return {
-    country,
-    timezone,
-    locale,
-    acceptLanguage,
-    languages,
-    timezoneOffset,
-    currency,
-    coordinates,
-    language: locale
-  };
-}
-function isGeoAligned(context) {
-  if (!context || !context.country) {
-    return false;
-  }
-  const country = context.country.toUpperCase();
-  if (context.timezone) {
-    if (!isValidTimezone(context.timezone)) {
-      return false;
-    }
-    if (!isTimezoneAlignedWithCountry(context.timezone, country)) {
-      return false;
-    }
-  }
-  if (context.locale) {
-    const config = getCountryConfig(country);
-    const localeNorm = context.locale.toLowerCase();
-    const configLocaleNorm = config.primaryLocale.toLowerCase();
-    const countryNorm = country.toLowerCase();
-    const matchesCountry = localeNorm.endsWith(`-${countryNorm}`) || localeNorm.endsWith(`_${countryNorm}`);
-    const matchesPrimary = localeNorm === configLocaleNorm;
-    const matchesLanguages = config.languages.some((l) => l.toLowerCase() === localeNorm);
-    if (!matchesCountry && !matchesPrimary && !matchesLanguages) {
-      return false;
-    }
-  }
-  return true;
-}
-function toLocaleProfile(geo) {
-  return {
-    language: geo.locale,
-    languages: [...geo.languages],
-    timezone: geo.timezone,
-    timezoneOffset: geo.timezoneOffset,
-    country: geo.country,
-    currency: geo.currency
-  };
-}
-function toGeoLocation(geo) {
-  return {
-    latitude: geo.coordinates.latitude,
-    longitude: geo.coordinates.longitude,
-    accuracy: geo.coordinates.accuracy ?? 1e3,
-    country: geo.country,
-    countryCode: geo.country,
-    timezone: geo.timezone,
-    locale: geo.locale,
-    languages: [...geo.languages]
-  };
-}
-
-const MACOS_PRESETS = [
-  {
-    id: "mac-m3-pro-mbp14",
-    name: 'MacBook Pro 14" (Apple M3 Pro)',
-    deviceType: "laptop",
-    os: {
-      name: "macOS",
-      platform: "macOS",
-      version: "15.0.0",
-      // macOS Sequoia
-      release: "Sequoia",
-      architecture: "arm"
-    },
-    hardware: {
-      screen: {
-        width: 1512,
-        height: 982,
-        availWidth: 1512,
-        availHeight: 945,
-        // Top notch & menu bar
-        dpr: 2,
-        colorDepth: 30,
-        pixelDepth: 30
-      },
-      cpu: {
-        architecture: "arm",
-        concurrency: 12
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 18
-      },
-      gpu: {
-        vendor: "Google Inc. (Apple)",
-        renderer: "ANGLE (Apple, Apple M3 Pro, OpenGL 4.1)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "mac-m2-air13",
-    name: 'MacBook Air 13" (Apple M2)',
-    deviceType: "laptop",
-    os: {
-      name: "macOS",
-      platform: "macOS",
-      version: "14.6.1",
-      // macOS Sonoma
-      release: "Sonoma",
-      architecture: "arm"
-    },
-    hardware: {
-      screen: {
-        width: 1440,
-        height: 900,
-        availWidth: 1440,
-        availHeight: 875,
-        dpr: 2,
-        colorDepth: 24,
-        pixelDepth: 24
-      },
-      cpu: {
-        architecture: "arm",
-        concurrency: 8
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 16
-      },
-      gpu: {
-        vendor: "Google Inc. (Apple)",
-        renderer: "ANGLE (Apple, Apple M2, OpenGL 4.1)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "mac-m2-max-mbp16",
-    name: 'MacBook Pro 16" (Apple M2 Max)',
-    deviceType: "laptop",
-    os: {
-      name: "macOS",
-      platform: "macOS",
-      version: "14.6.1",
-      release: "Sonoma",
-      architecture: "arm"
-    },
-    hardware: {
-      screen: {
-        width: 1728,
-        height: 1117,
-        availWidth: 1728,
-        availHeight: 1080,
-        dpr: 2,
-        colorDepth: 30,
-        pixelDepth: 30
-      },
-      cpu: {
-        architecture: "arm",
-        concurrency: 12
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 32
-      },
-      gpu: {
-        vendor: "Google Inc. (Apple)",
-        renderer: "ANGLE (Apple, Apple M2 Max, OpenGL 4.1)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "mac-m3-imac24",
-    name: 'iMac 24" (Apple M3)',
-    deviceType: "desktop",
-    os: {
-      name: "macOS",
-      platform: "macOS",
-      version: "15.0.0",
-      release: "Sequoia",
-      architecture: "arm"
-    },
-    hardware: {
-      screen: {
-        width: 2240,
-        height: 1260,
-        availWidth: 2240,
-        availHeight: 1235,
-        dpr: 2,
-        colorDepth: 30,
-        pixelDepth: 30
-      },
-      cpu: {
-        architecture: "arm",
-        concurrency: 8
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 16
-      },
-      gpu: {
-        vendor: "Google Inc. (Apple)",
-        renderer: "ANGLE (Apple, Apple M3, OpenGL 4.1)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "mac-m2-studio-display",
-    name: "Mac Studio (Apple M2 Max, Studio Display)",
-    deviceType: "desktop",
-    os: {
-      name: "macOS",
-      platform: "macOS",
-      version: "15.0.0",
-      release: "Sequoia",
-      architecture: "arm"
-    },
-    hardware: {
-      screen: {
-        width: 2560,
-        height: 1440,
-        availWidth: 2560,
-        availHeight: 1415,
-        dpr: 2,
-        colorDepth: 30,
-        pixelDepth: 30
-      },
-      cpu: {
-        architecture: "arm",
-        concurrency: 12
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 32
-      },
-      gpu: {
-        vendor: "Google Inc. (Apple)",
-        renderer: "ANGLE (Apple, Apple M2 Max, OpenGL 4.1)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "mac-intel-mbp13",
-    name: 'MacBook Pro 13" (Intel Core i5)',
-    deviceType: "laptop",
-    os: {
-      name: "macOS",
-      platform: "macOS",
-      version: "14.6.1",
-      release: "Sonoma",
-      architecture: "x86"
-    },
-    hardware: {
-      screen: {
-        width: 1440,
-        height: 900,
-        availWidth: 1440,
-        availHeight: 875,
-        dpr: 2,
-        colorDepth: 24,
-        pixelDepth: 24
-      },
-      cpu: {
-        architecture: "x86",
-        concurrency: 8
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 16
-      },
-      gpu: {
-        vendor: "Google Inc. (Intel)",
-        renderer: "ANGLE (Intel, Intel(R) Iris(TM) Plus Graphics 645, OpenGL 4.1)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  }
-];
-const WINDOWS_PRESETS = [
-  {
-    id: "win11-rtx3060-desktop",
-    name: "Windows 11 Desktop (NVIDIA RTX 3060)",
-    deviceType: "desktop",
-    os: {
-      name: "Windows",
-      platform: "Windows",
-      version: "15.0.0",
-      // Windows 11
-      release: "Windows 11",
-      architecture: "x86"
-    },
-    hardware: {
-      screen: {
-        width: 1920,
-        height: 1080,
-        availWidth: 1920,
-        availHeight: 1040,
-        // 40px taskbar
-        dpr: 1,
-        colorDepth: 24,
-        pixelDepth: 24
-      },
-      cpu: {
-        architecture: "x86",
-        concurrency: 12
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 16
-      },
-      gpu: {
-        vendor: "Google Inc. (NVIDIA)",
-        renderer: "ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "win11-rtx4070-laptop",
-    name: "Windows 11 Laptop (NVIDIA RTX 4070, 2K 125%)",
-    deviceType: "laptop",
-    os: {
-      name: "Windows",
-      platform: "Windows",
-      version: "15.0.0",
-      release: "Windows 11",
-      architecture: "x86"
-    },
-    hardware: {
-      screen: {
-        width: 2560,
-        height: 1440,
-        availWidth: 2560,
-        availHeight: 1400,
-        dpr: 1.25,
-        colorDepth: 24,
-        pixelDepth: 24
-      },
-      cpu: {
-        architecture: "x86",
-        concurrency: 16
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 32
-      },
-      gpu: {
-        vendor: "Google Inc. (NVIDIA)",
-        renderer: "ANGLE (NVIDIA, NVIDIA GeForce RTX 4070 Direct3D11)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "win10-gtx1660s-desktop",
-    name: "Windows 10 Desktop (NVIDIA GTX 1660 SUPER)",
-    deviceType: "desktop",
-    os: {
-      name: "Windows",
-      platform: "Windows",
-      version: "10.0.0",
-      // Windows 10
-      release: "Windows 10",
-      architecture: "x86"
-    },
-    hardware: {
-      screen: {
-        width: 1920,
-        height: 1080,
-        availWidth: 1920,
-        availHeight: 1040,
-        dpr: 1,
-        colorDepth: 24,
-        pixelDepth: 24
-      },
-      cpu: {
-        architecture: "x86",
-        concurrency: 8
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 16
-      },
-      gpu: {
-        vendor: "Google Inc. (NVIDIA)",
-        renderer: "ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 SUPER Direct3D11)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "win10-rx6700xt-desktop",
-    name: "Windows 10 Workstation (AMD Radeon RX 6700 XT)",
-    deviceType: "desktop",
-    os: {
-      name: "Windows",
-      platform: "Windows",
-      version: "10.0.0",
-      release: "Windows 10",
-      architecture: "x86"
-    },
-    hardware: {
-      screen: {
-        width: 2560,
-        height: 1440,
-        availWidth: 2560,
-        availHeight: 1400,
-        dpr: 1,
-        colorDepth: 24,
-        pixelDepth: 24
-      },
-      cpu: {
-        architecture: "x86",
-        concurrency: 16
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 32
-      },
-      gpu: {
-        vendor: "Google Inc. (AMD)",
-        renderer: "ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "win11-iris-xe-laptop",
-    name: "Windows 11 Ultrabook (Intel Iris Xe)",
-    deviceType: "laptop",
-    os: {
-      name: "Windows",
-      platform: "Windows",
-      version: "15.0.0",
-      release: "Windows 11",
-      architecture: "x86"
-    },
-    hardware: {
-      screen: {
-        width: 1920,
-        height: 1080,
-        availWidth: 1920,
-        availHeight: 1032,
-        dpr: 1.25,
-        colorDepth: 24,
-        pixelDepth: 24
-      },
-      cpu: {
-        architecture: "x86",
-        concurrency: 8
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 16
-      },
-      gpu: {
-        vendor: "Google Inc. (Intel)",
-        renderer: "ANGLE (Intel, Intel(R) Iris(R) Xe Graphics Direct3D11)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  },
-  {
-    id: "win11-rtx4080-4k",
-    name: "Windows 11 High-End 4K (NVIDIA RTX 4080)",
-    deviceType: "desktop",
-    os: {
-      name: "Windows",
-      platform: "Windows",
-      version: "15.0.0",
-      release: "Windows 11",
-      architecture: "x86"
-    },
-    hardware: {
-      screen: {
-        width: 3840,
-        height: 2160,
-        availWidth: 3840,
-        availHeight: 2112,
-        dpr: 1.5,
-        colorDepth: 24,
-        pixelDepth: 24
-      },
-      cpu: {
-        architecture: "x86",
-        concurrency: 24
-      },
-      memory: {
-        deviceMemory: 8,
-        physicalMemoryGB: 32
-      },
-      gpu: {
-        vendor: "Google Inc. (NVIDIA)",
-        renderer: "ANGLE (NVIDIA, NVIDIA GeForce RTX 4080 Direct3D11)",
-        webglVendor: "WebKit",
-        webglRenderer: "WebKit WebGL"
-      }
-    }
-  }
-];
-const ALL_PRESETS = [
-  ...MACOS_PRESETS,
-  ...WINDOWS_PRESETS
-];
-function getHardwarePresets(filters) {
-  let list = ALL_PRESETS;
-  if (!filters) return list;
-  if (filters.platform) {
-    list = list.filter((p) => p.os.platform === filters.platform);
-  }
-  if (filters.architecture) {
-    list = list.filter((p) => p.os.architecture === filters.architecture);
-  }
-  if (filters.deviceType) {
-    list = list.filter((p) => p.deviceType === filters.deviceType);
-  }
-  return list;
-}
-function validateHardwareContradictions(os, hardware) {
-  const errors = [];
-  if (os.platform === "macOS") {
-    if (hardware.gpu.renderer.includes("Direct3D")) {
-      errors.push("macOS cannot use Direct3D graphics backend");
-    }
-    if (os.architecture === "arm") {
-      if (!hardware.gpu.renderer.includes("Apple M")) {
-        errors.push(`ARM macOS must use Apple Silicon M-series GPU, got: ${hardware.gpu.renderer}`);
-      }
-      if (hardware.gpu.renderer.includes("NVIDIA") || hardware.gpu.renderer.includes("AMD")) {
-        errors.push("Apple Silicon Mac cannot have discrete NVIDIA or AMD GPU");
-      }
-    } else if (os.architecture === "x86") {
-      if (hardware.gpu.renderer.includes("Apple M")) {
-        errors.push("Intel x86 Mac cannot have Apple Silicon M-series GPU");
-      }
-    }
-    if (hardware.screen.dpr !== 2) {
-      errors.push(`Modern macOS profiles must be Retina (dpr: 2), got: ${hardware.screen.dpr}`);
-    }
-  } else if (os.platform === "Windows") {
-    if (hardware.gpu.renderer.includes("Apple M")) {
-      errors.push("Windows cannot use Apple Silicon GPU");
-    }
-    if (os.architecture === "x86" && !hardware.gpu.renderer.includes("Direct3D")) {
-      errors.push("Windows x86 ANGLE backend should use Direct3D11");
-    }
-    if (os.version !== "15.0.0" && os.version !== "10.0.0") {
-      errors.push(`Windows platform version must be 15.0.0 (Win11) or 10.0.0 (Win10), got: ${os.version}`);
-    }
-  }
-  if (hardware.screen.availWidth > hardware.screen.width) {
-    errors.push("screen.availWidth cannot be greater than screen.width");
-  }
-  if (hardware.screen.availHeight > hardware.screen.height) {
-    errors.push("screen.availHeight cannot be greater than screen.height");
-  }
-  if (hardware.screen.width <= 0 || hardware.screen.height <= 0) {
-    errors.push("Screen dimensions must be strictly positive");
-  }
-  if (hardware.cpu.concurrency < 2 || hardware.cpu.concurrency > 64) {
-    errors.push(`Unrealistic hardware concurrency: ${hardware.cpu.concurrency}`);
-  }
-  if (hardware.cpu.architecture !== os.architecture) {
-    errors.push(
-      `CPU architecture (${hardware.cpu.architecture}) does not match OS architecture (${os.architecture})`
-    );
-  }
-  if (hardware.memory.deviceMemory <= 0 || hardware.memory.deviceMemory > 128) {
-    errors.push(`Invalid deviceMemory: ${hardware.memory.deviceMemory}`);
-  }
-  return errors;
-}
-
-function murmur3(key, seed = 0) {
-  let h1 = seed >>> 0;
-  const c1 = 3432918353;
-  const c2 = 461845907;
-  const len = key.length;
-  for (let i = 0; i < len; i++) {
-    let k1 = key.charCodeAt(i);
-    k1 = Math.imul(k1, c1);
-    k1 = k1 << 15 | k1 >>> 17;
-    k1 = Math.imul(k1, c2);
-    h1 ^= k1;
-    h1 = h1 << 13 | h1 >>> 19;
-    h1 = Math.imul(h1, 5) + 3864292196 >>> 0;
-  }
-  h1 ^= len;
-  h1 ^= h1 >>> 16;
-  h1 = Math.imul(h1, 2246822507);
-  h1 ^= h1 >>> 13;
-  h1 = Math.imul(h1, 3266489909);
-  h1 ^= h1 >>> 16;
-  return h1 >>> 0;
-}
-function fnv1a(key) {
-  let hash = 2166136261;
-  for (let i = 0; i < key.length; i++) {
-    hash ^= key.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-function createMulberry32(seed) {
-  let s = seed >>> 0;
-  return function() {
-    s = s + 1831565813 >>> 0;
-    let t = Math.imul(s ^ s >>> 15, 1 | s);
-    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
-function createDeterministicPRNG(seed) {
-  const numericSeed = typeof seed === "number" ? seed >>> 0 : murmur3(String(seed));
-  return createMulberry32(numericSeed);
-}
-const CHROME_VERSIONS = [
-  { major: 131, full: "131.0.6778.86" },
-  { major: 130, full: "130.0.6723.116" },
-  { major: 128, full: "128.0.6613.137" },
-  { major: 126, full: "126.0.6478.182" },
-  { major: 124, full: "124.0.6367.208" }
-];
-const EDGE_VERSIONS = [
-  { major: 131, full: "131.0.2903.70" },
-  { major: 130, full: "130.0.2849.68" },
-  { major: 128, full: "128.0.2739.67" },
-  { major: 126, full: "126.0.2592.87" }
-];
-function buildUserAgent(browserName, fullVersion, os) {
-  if (os.platform === "macOS") {
-    if (browserName === "Edge") {
-      return `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${fullVersion} Safari/537.36 Edg/${fullVersion}`;
-    }
-    return `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${fullVersion} Safari/537.36`;
-  }
-  if (browserName === "Edge") {
-    return `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${fullVersion} Safari/537.36 Edg/${fullVersion}`;
-  }
-  return `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${fullVersion} Safari/537.36`;
-}
-function getStaticFallbackHeaders(userAgent, clientHintsHeaders, acceptLanguage) {
-  return {
-    ...clientHintsHeaders,
-    "user-agent": userAgent,
-    accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-    "accept-encoding": "gzip, deflate, br, zstd",
-    "accept-language": acceptLanguage,
-    "upgrade-insecure-requests": "1",
-    "sec-fetch-dest": "document",
-    "sec-fetch-mode": "navigate",
-    "sec-fetch-site": "none",
-    "sec-fetch-user": "?1",
-    priority: "u=0, i"
-  };
-}
-function getApifyHeadersIfAvailable(browserName, os, userAgent, clientHintsHeaders, acceptLanguage) {
-  try {
-    const hgModule = require("header-generator");
-    const HeaderGenerator = hgModule.HeaderGenerator;
-    if (HeaderGenerator) {
-      const generator = new HeaderGenerator({
-        browsers: [{ name: browserName === "Edge" ? "edge" : "chrome" }],
-        operatingSystems: [os.platform === "macOS" ? "macos" : "windows"]
-      });
-      const generated = generator.getHeaders();
-      return {
-        ...generated,
-        ...clientHintsHeaders,
-        "user-agent": userAgent,
-        "accept-language": acceptLanguage
-      };
-    }
-  } catch {
-  }
-  return getStaticFallbackHeaders(userAgent, clientHintsHeaders, acceptLanguage);
-}
-function generatePassport(options = {}) {
-  const seedString = options.seed !== void 0 ? String(options.seed) : generateRandomSeed();
-  const prng = createDeterministicPRNG(seedString);
-  const presets = getHardwarePresets({
-    platform: options.os
-  });
-  const presetIndex = Math.floor(prng() * presets.length);
-  const preset = presets[presetIndex] ?? ALL_PRESETS[0];
-  const os = { ...preset.os };
-  const hardware = {
-    screen: { ...preset.hardware.screen },
-    cpu: { ...preset.hardware.cpu },
-    memory: { ...preset.hardware.memory },
-    gpu: { ...preset.hardware.gpu }
-  };
-  const browserName = options.browser ?? (prng() > 0.85 ? "Edge" : "Chrome");
-  const versionPool = browserName === "Edge" ? EDGE_VERSIONS : CHROME_VERSIONS;
-  const versionIndex = Math.floor(prng() * versionPool.length);
-  const selectedVersion = versionPool[versionIndex];
-  const userAgent = buildUserAgent(browserName, selectedVersion.full, os);
-  const browser = {
-    name: browserName,
-    version: selectedVersion.full,
-    majorVersion: selectedVersion.major,
-    userAgent
-  };
-  const clientHints = generateUserAgentClientHints({
-    browserName,
-    fullVersion: selectedVersion.full,
-    majorVersion: selectedVersion.major,
-    os,
-    prng
-  });
-  const geoContext = alignGeoContext({
-    country: options.geo || options.country,
-    proxyUrl: options.proxy || options.proxyUrl,
-    timezone: options.timezone,
-    locale: options.locale
-  });
-  const locale = {
-    language: geoContext.locale,
-    languages: geoContext.languages,
-    timezone: geoContext.timezone,
-    timezoneOffset: geoContext.timezoneOffset,
-    country: geoContext.country,
-    currency: geoContext.currency,
-    acceptLanguage: geoContext.acceptLanguage
-  };
-  const acceptLanguage = geoContext.acceptLanguage;
-  let headers;
-  if (options.useHeaderGenerator) {
-    headers = getApifyHeadersIfAvailable(
-      browserName,
-      os,
-      userAgent,
-      clientHints.headers,
-      acceptLanguage
-    );
-  } else {
-    headers = getStaticFallbackHeaders(
-      userAgent,
-      clientHints.headers,
-      acceptLanguage
-    );
-  }
-  const context = {
-    viewport: {
-      width: hardware.screen.availWidth,
-      height: hardware.screen.availHeight
-    },
-    userAgent,
-    locale: locale.language,
-    timezoneId: locale.timezone,
-    extraHTTPHeaders: headers,
-    deviceScaleFactor: hardware.screen.dpr,
-    hasTouch: false,
-    isMobile: false,
-    colorScheme: "light"
-  };
-  const contradictions = validateHardwareContradictions(os, hardware);
-  const evaluation = {
-    overallScore: contradictions.length === 0 ? 100 : Math.max(0, 100 - contradictions.length * 25),
-    status: contradictions.length === 0 ? "PASS" : "FAIL",
-    grade: contradictions.length === 0 ? "A+" : "F",
-    checks: [
-      {
-        id: "os_ua_alignment",
-        name: "OS and User-Agent Alignment",
-        category: "os_ua_alignment",
-        passed: true,
-        score: 100,
-        weight: 1,
-        message: "Platform and frozen User-Agent string match W3C specs with zero contradiction"
-      },
-      {
-        id: "client_hints_entropy",
-        name: "High-Entropy Client Hints Completeness",
-        category: "client_hints_entropy",
-        passed: true,
-        score: 100,
-        weight: 1,
-        message: "RFC 8942 Client Hints and platform versions fully populated and formatted"
-      },
-      {
-        id: "hardware_plausibility",
-        name: "Hardware Matrix Plausibility",
-        category: "hardware_plausibility",
-        passed: contradictions.length === 0,
-        score: contradictions.length === 0 ? 100 : 0,
-        weight: 1.5,
-        message: contradictions.length === 0 ? "All hardware parameters (screen, cpu, memory, gpu) are physically plausible" : `Contradictions detected: ${contradictions.join("; ")}`
-      },
-      {
-        id: "webgl_hardware_coupling",
-        name: "WebGL GPU Coupling",
-        category: "webgl_hardware_coupling",
-        passed: true,
-        score: 100,
-        weight: 1.2,
-        message: `GPU renderer [${hardware.gpu.renderer}] is authentic for ${os.platform} (${os.architecture})`
-      }
-    ],
-    entropyAnalysis: {
-      estimatedBits: 48.5,
-      collisionRisk: "very_low",
-      fingerprintUniqueness: 0.99999
-    },
-    evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const id = `pass_${node_crypto.createHash("sha256").update(seedString).digest("hex").slice(0, 16)}`;
-  return {
-    id,
-    seed: seedString,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    browser,
-    os,
-    hardware,
-    locale,
-    headers,
-    clientHints,
-    context,
-    evaluation,
-    getHeaders(overrides) {
-      if (!overrides) return { ...headers };
-      return { ...headers, ...overrides };
-    }
-  };
-}
-const generateDevicePassport = generatePassport;
-function generateRandomSeed() {
-  const buf = new Uint32Array(4);
-  for (let i = 0; i < 4; i++) {
-    buf[i] = Math.floor(Math.random() * 4294967295);
-  }
-  return Array.from(buf).map((x) => x.toString(16).padStart(8, "0")).join("");
-}
-
-class JSONFileStorage {
-  filePath;
-  pretty;
-  autoSave;
-  cache = /* @__PURE__ */ new Map();
-  isLoaded = false;
-  writeQueue = Promise.resolve();
-  constructor(filePathOrOptions) {
-    if (typeof filePathOrOptions === "string") {
-      this.filePath = path__default.resolve(filePathOrOptions);
-      this.pretty = true;
-      this.autoSave = true;
-    } else {
-      this.filePath = path__default.resolve(filePathOrOptions.filePath);
-      this.pretty = filePathOrOptions.pretty ?? true;
-      this.autoSave = filePathOrOptions.autoSave ?? true;
-    }
-  }
-  /**
-   * Ensure data is loaded from disk into the in-memory cache.
-   */
-  ensureLoaded() {
-    if (this.isLoaded) return;
-    this.isLoaded = true;
-    if (!fs__default.existsSync(this.filePath)) {
-      return;
-    }
-    try {
-      const raw = fs__default.readFileSync(this.filePath, "utf-8").trim();
-      if (!raw) return;
-      const data = JSON.parse(raw);
-      if (typeof data === "object" && data !== null) {
-        for (const [key, value] of Object.entries(data)) {
-          this.cache.set(key, value);
-        }
-      }
-    } catch (err) {
-      const corruptBackup = `${this.filePath}.corrupt-${Date.now()}`;
-      try {
-        fs__default.copyFileSync(this.filePath, corruptBackup);
-      } catch {
-      }
-      throw new Error(
-        `[JSONFileStorage] Failed to parse JSON file at ${this.filePath}: ${err.message}. A backup was created at ${corruptBackup}`
-      );
-    }
-  }
-  /**
-   * Atomic flush to disk. Writes to a unique temp file in the same directory,
-   * then atomically renames it to target file.
-   */
-  flushAtomic() {
-    const dir = path__default.dirname(this.filePath);
-    if (!fs__default.existsSync(dir)) {
-      fs__default.mkdirSync(dir, { recursive: true });
-    }
-    const obj = {};
-    for (const [k, v] of this.cache.entries()) {
-      obj[k] = v;
-    }
-    const jsonString = this.pretty ? JSON.stringify(obj, null, 2) : JSON.stringify(obj);
-    const nonce = Math.random().toString(36).slice(2, 8);
-    const tmpPath = path__default.join(dir, `.${path__default.basename(this.filePath)}.${process.pid}.${Date.now()}.${nonce}.tmp`);
-    try {
-      fs__default.writeFileSync(tmpPath, jsonString, "utf-8");
-      fs__default.renameSync(tmpPath, this.filePath);
-    } catch (err) {
-      if (fs__default.existsSync(tmpPath)) {
-        try {
-          fs__default.unlinkSync(tmpPath);
-        } catch {
-        }
-      }
-      throw err;
-    }
-  }
-  /**
-   * Queue a disk write to prevent race conditions during rapid concurrent mutations.
-   */
-  queueSave() {
-    if (!this.autoSave) {
-      return Promise.resolve();
-    }
-    this.writeQueue = this.writeQueue.then(() => {
-      this.flushAtomic();
-    }).catch((err) => {
-      return Promise.reject(err);
-    });
-    return this.writeQueue;
-  }
-  async get(key) {
-    return this.getSync(key);
-  }
-  getSync(key) {
-    this.ensureLoaded();
-    const val = this.cache.get(key);
-    return val !== void 0 ? val : null;
-  }
-  async set(key, value) {
-    this.ensureLoaded();
-    this.cache.set(key, value);
-    await this.queueSave();
-  }
-  setSync(key, value) {
-    this.ensureLoaded();
-    this.cache.set(key, value);
-    if (this.autoSave) {
-      this.flushAtomic();
-    }
-  }
-  async has(key) {
-    return this.hasSync(key);
-  }
-  hasSync(key) {
-    this.ensureLoaded();
-    return this.cache.has(key);
-  }
-  async delete(key) {
-    this.ensureLoaded();
-    const existed = this.cache.delete(key);
-    if (existed && this.autoSave) {
-      await this.queueSave();
-    }
-    return existed;
-  }
-  deleteSync(key) {
-    this.ensureLoaded();
-    const existed = this.cache.delete(key);
-    if (existed && this.autoSave) {
-      this.flushAtomic();
-    }
-    return existed;
-  }
-  async keys() {
-    return this.keysSync();
-  }
-  keysSync() {
-    this.ensureLoaded();
-    return Array.from(this.cache.keys());
-  }
-  async clear() {
-    this.ensureLoaded();
-    this.cache.clear();
-    if (this.autoSave) {
-      await this.queueSave();
-    }
-  }
-  clearSync() {
-    this.ensureLoaded();
-    this.cache.clear();
-    if (this.autoSave) {
-      this.flushAtomic();
-    }
-  }
-  /**
-   * Explicitly force a flush to disk (useful if autoSave is set to false).
-   */
-  async flush() {
-    await this.queueSave();
-  }
-  flushSync() {
-    this.flushAtomic();
-  }
-  get size() {
-    this.ensureLoaded();
-    return this.cache.size;
-  }
-}
+const cdp = require('./shared/device-passport.CLaBZWUV.cjs');
+const evaluator_index = require('./evaluator/index.cjs');
+const memory = require('./shared/device-passport.Cjxlv8xI.cjs');
+const geo_index = require('./geo/index.cjs');
+const aligner = require('./shared/device-passport.BPd2-w8e.cjs');
+require('node:crypto');
+require('node:fs');
+require('node:path');
 
 class DevicePassportInstance {
   profile;
@@ -3320,25 +79,25 @@ class DevicePassportInstance {
    * Essential for anti-bot evasion against Cloudflare, Akamai, and DataDome.
    */
   getHeaders(overrides) {
-    return formatCanonicalHeaders(this.profile.headers, overrides);
+    return cdp.formatCanonicalHeaders(this.profile.headers, overrides);
   }
   /**
    * Returns a higher-order fetch function wrapping standard fetch with this passport's canonical persona.
    */
   wrapFetch(customFetch) {
-    return withPassport(this, customFetch);
+    return cdp.withPassport(this, customFetch);
   }
   /**
    * Alias for wrapFetch.
    */
   withPassport(customFetch) {
-    return withPassport(this, customFetch);
+    return cdp.withPassport(this, customFetch);
   }
   /**
    * Generates a copy-pasteable cURL command with correct browser headers and User-Agent.
    */
   toCurl(url, options) {
-    return toCurl(this, url, options);
+    return cdp.toCurl(this, url, options);
   }
   // ==========================================
   // Heavyweight Browser Automation Adapters
@@ -3351,32 +110,32 @@ class DevicePassportInstance {
    * ```
    */
   getPlaywrightContext() {
-    return getPlaywrightContext(this.profile);
+    return cdp.getPlaywrightContext(this.profile);
   }
   /**
    * Returns Puppeteer launch args and page emulation parameters.
    */
   getPuppeteerArgs() {
-    return getPuppeteerArgs(this.profile);
+    return cdp.getPuppeteerArgs(this.profile);
   }
   /**
    * Generates an in-page stealth script to patch runtime JavaScript APIs
    * (navigator.webdriver, hardwareConcurrency, deviceMemory, WebGL, Client Hints).
    */
   getStealthScript() {
-    return getStealthScript(this.profile);
+    return cdp.getStealthScript(this.profile);
   }
   /**
    * Injects stealth scripts and extra HTTP headers into a Playwright BrowserContext.
    */
   async applyToPlaywright(context) {
-    await applyToPlaywrightContext(context, this.profile);
+    await cdp.applyToPlaywrightContext(context, this.profile);
   }
   /**
    * Injects stealth scripts and emulation parameters into a Puppeteer Page.
    */
   async applyToPuppeteer(page) {
-    await applyToPuppeteerPage(page, this.profile);
+    await cdp.applyToPuppeteerPage(page, this.profile);
   }
   // ==========================================
   // Consistency & Diagnostics
@@ -3390,11 +149,11 @@ class DevicePassportInstance {
       return this.profile.evaluation;
     }
     try {
-      const contradictions = detectAllContradictions(this.profile);
+      const contradictions = evaluator_index.detectAllContradictions(this.profile);
       let estimatedBits = 48;
       let collisionRisk = "very_low";
       try {
-        const entropy = analyzeHeaderEntropy(this.profile.headers);
+        const entropy = evaluator_index.analyzeHeaderEntropy(this.profile.headers);
         if (entropy) {
           estimatedBits = entropy.estimatedBits;
           collisionRisk = entropy.collisionRisk;
@@ -3501,12 +260,12 @@ function createPassport(seedOrOptionsOrProfile, extraOptions) {
     options = { ...extraOptions };
   }
   if (options.store && options.seed) {
-    const storage = typeof options.store === "string" ? new JSONFileStorage({ filePath: options.store }) : options.store;
+    const storage = typeof options.store === "string" ? new memory.JSONFileStorage({ filePath: options.store }) : options.store;
     if (storage.hasSync && storage.hasSync(options.seed)) {
       const existing = storage.getSync(options.seed);
       if (existing) return new DevicePassportInstance(existing);
     }
-    const generated2 = generatePassport(options);
+    const generated2 = cdp.generatePassport(options);
     if (storage.setSync) {
       storage.setSync(options.seed, generated2);
     } else {
@@ -3515,74 +274,10 @@ function createPassport(seedOrOptionsOrProfile, extraOptions) {
     }
     return new DevicePassportInstance(generated2);
   }
-  const generated = generatePassport(options);
+  const generated = cdp.generatePassport(options);
   return new DevicePassportInstance(generated);
 }
 
-class MemoryStorage {
-  store = /* @__PURE__ */ new Map();
-  clone;
-  constructor(options) {
-    this.clone = options?.clone ?? true;
-  }
-  deepClone(val) {
-    if (!this.clone || val === null || typeof val !== "object") {
-      return val;
-    }
-    if (typeof structuredClone === "function") {
-      try {
-        return structuredClone(val);
-      } catch {
-        return JSON.parse(JSON.stringify(val));
-      }
-    }
-    return JSON.parse(JSON.stringify(val));
-  }
-  async get(key) {
-    return this.getSync(key);
-  }
-  getSync(key) {
-    const val = this.store.get(key);
-    if (val === void 0) {
-      return null;
-    }
-    return this.deepClone(val);
-  }
-  async set(key, value) {
-    this.setSync(key, value);
-  }
-  setSync(key, value) {
-    this.store.set(key, this.deepClone(value));
-  }
-  async has(key) {
-    return this.hasSync(key);
-  }
-  hasSync(key) {
-    return this.store.has(key);
-  }
-  async delete(key) {
-    return this.deleteSync(key);
-  }
-  deleteSync(key) {
-    return this.store.delete(key);
-  }
-  async keys() {
-    return this.keysSync();
-  }
-  keysSync() {
-    return Array.from(this.store.keys());
-  }
-  async clear() {
-    this.clearSync();
-  }
-  clearSync() {
-    this.store.clear();
-  }
-  get size() {
-    return this.store.size;
-  }
-}
-
 class PassportManager {
   storage;
   defaultGeo;
@@ -3591,16 +286,16 @@ class PassportManager {
   generator;
   constructor(options) {
     if (typeof options?.store === "string") {
-      this.storage = new JSONFileStorage(options.store);
+      this.storage = new memory.JSONFileStorage(options.store);
     } else if (options?.store && typeof options.store.get === "function") {
       this.storage = options.store;
     } else {
-      this.storage = new MemoryStorage();
+      this.storage = new memory.MemoryStorage();
     }
     this.defaultGeo = options?.defaultGeo ?? "US";
     this.defaultOS = options?.defaultOS;
     this.defaultBrowser = options?.defaultBrowser;
-    this.generator = options?.generator ?? generatePassport;
+    this.generator = options?.generator ?? cdp.generatePassport;
   }
   /**
    * Retrieves an existing sticky passport by seed or deterministically generates
@@ -3725,135 +420,6 @@ class PassportManager {
   }
 }
 
-const GEO_LOCALES = COUNTRY_LOCALES;
-const TIMEZONE_MATRIX = TIMEZONE_TO_COUNTRY;
-const isValidCountryCode = hasCountryConfig;
-function detectGeoFromUrl(url) {
-  return extractCountryFromProxyUrl(url);
-}
-function getLocaleProfile(countryCode, timezone) {
-  const geo = alignGeoContext({
-    country: countryCode || void 0,
-    timezone
-  });
-  return toLocaleProfile(geo);
-}
-
-function evaluateGeoAlignment(passport) {
-  const geoContradictions = detectGeoChronoContradictions(passport);
-  let score = 100;
-  for (const c of geoContradictions) {
-    score -= c.impactPenalty;
-  }
-  const acceptLang = passport.headers["accept-language"] || "";
-  if (acceptLang) {
-    if (!/^[a-zA-Z]{2,3}(-[a-zA-Z0-9]+)?(;q=[0-1](\.\d{1,3})?)?/.test(acceptLang.trim())) {
-      score -= 10;
-    }
-  } else {
-    score -= 15;
-  }
-  return Math.max(0, Math.min(100, score));
-}
-function evaluateCoherence(passport) {
-  const contradictions = detectAllContradictions(passport);
-  const geoAlignmentScore = evaluateGeoAlignment(passport);
-  const entropyResult = analyzeHeaderEntropy(passport.headers || {});
-  const entropyScore = entropyResult.entropyScore;
-  let totalPenalty = 0;
-  let fatalCount = 0;
-  let warningCount = 0;
-  for (const item of contradictions) {
-    totalPenalty += item.impactPenalty;
-    if (item.severity === "fatal") {
-      fatalCount++;
-    } else {
-      warningCount++;
-    }
-  }
-  if (entropyResult.anomaly !== "optimal") {
-    const entropyPenalty = Math.max(0, 100 - entropyScore) * 0.25;
-    totalPenalty += entropyPenalty;
-  }
-  const rawCoherence = 100 - totalPenalty;
-  const coherenceScore = Number(Math.max(0, Math.min(100, rawCoherence)).toFixed(1));
-  const hContradictions = contradictions.filter((c) => c.category === "hardware_system");
-  const sContradictions = contradictions.filter((c) => c.category === "os_browser");
-  const gContradictions = contradictions.filter((c) => c.category === "geo_chrono");
-  const cContradictions = contradictions.filter((c) => c.category === "client_hints");
-  const calcSubScore = (list) => Math.max(0, 100 - list.reduce((acc, curr) => acc + curr.impactPenalty, 0));
-  const mathematicalModel = {
-    formalism: "P = \u27E8H, S, G, C\u27E9",
-    definition: {
-      H: "Hardware Sub-space \u27E8Screen, CPU, Memory, GPU\u27E9",
-      S: "System Sub-space \u27E8OS, Browser, UserAgent\u27E9",
-      G: "Geo-Chrono Sub-space \u27E8Country, Timezone, Locale, Languages, Coordinates\u27E9",
-      C: "Client-Hints Sub-space \u27E8Sec-CH-UA*, Low & High Entropy Hints\u27E9"
-    },
-    subspaces: {
-      H: {
-        valid: hContradictions.every((c) => c.severity !== "fatal"),
-        score: calcSubScore(hContradictions),
-        notes: hContradictions.map((c) => c.description)
-      },
-      S: {
-        valid: sContradictions.every((c) => c.severity !== "fatal"),
-        score: calcSubScore(sContradictions),
-        notes: sContradictions.map((c) => c.description)
-      },
-      G: {
-        valid: gContradictions.every((c) => c.severity !== "fatal"),
-        score: geoAlignmentScore,
-        notes: gContradictions.map((c) => c.description)
-      },
-      C: {
-        valid: cContradictions.every((c) => c.severity !== "fatal"),
-        score: calcSubScore(cContradictions),
-        notes: cContradictions.map((c) => c.description)
-      }
-    }
-  };
-  let grade = "F";
-  if (fatalCount === 0) {
-    if (coherenceScore >= 95 && entropyScore >= 80) grade = "A+";
-    else if (coherenceScore >= 88) grade = "A";
-    else if (coherenceScore >= 75) grade = "B";
-    else grade = "C";
-  } else {
-    grade = "F";
-  }
-  const passed = fatalCount === 0 && coherenceScore >= 80;
-  let verdict = "";
-  if (grade === "A+") {
-    verdict = "Flawless mathematical coherence. Zero contradictions across H, S, G, C spaces.";
-  } else if (grade === "A") {
-    verdict = "High consistency persona with natural browser characteristics and low bot detection risk.";
-  } else if (grade === "B" || grade === "C") {
-    verdict = "Minor cross-layer discrepancies detected; susceptible to advanced anti-bot heuristics.";
-  } else {
-    verdict = "Fatal architectural contradiction detected. Persona is trivially flagged by Cloudflare/DataDome.";
-  }
-  return {
-    coherenceScore,
-    geoAlignmentScore,
-    entropyScore,
-    contradictions,
-    mathematicalModel,
-    entropyAnalysis: entropyResult,
-    summary: {
-      passed,
-      fatalCount,
-      warningCount,
-      grade,
-      verdict
-    }
-  };
-}
-
-function evaluatePassport(passport) {
-  return evaluateCoherence(passport);
-}
-
 const BENCHMARK_METRICS_METADATA = {
   clientHintsSupport: {
     id: "clientHintsSupport",
@@ -4226,97 +792,101 @@ function formatComparativeMatrixJSON() {
 
 const VERSION = "1.0.0";
 
-exports.ALL_PRESETS = ALL_PRESETS;
-exports.ALPHA3_TO_ALPHA2 = ALPHA3_TO_ALPHA2;
-exports.BASELINE_OPTIMAL_ENTROPY = BASELINE_OPTIMAL_ENTROPY;
+exports.ALL_PRESETS = cdp.ALL_PRESETS;
+exports.CANONICAL_HEADER_ORDER = cdp.CANONICAL_HEADER_ORDER;
+exports.CHROME_VERSIONS = cdp.CHROME_VERSIONS;
+exports.EDGE_VERSIONS = cdp.EDGE_VERSIONS;
+exports.MACOS_PRESETS = cdp.MACOS_PRESETS;
+exports.WINDOWS_PRESETS = cdp.WINDOWS_PRESETS;
+exports.applyCdpPassport = cdp.applyCdpPassport;
+exports.applyToPlaywrightContext = cdp.applyToPlaywrightContext;
+exports.applyToPuppeteerPage = cdp.applyToPuppeteerPage;
+exports.buildUserAgent = cdp.buildUserAgent;
+exports.createDeterministicPRNG = cdp.createDeterministicPRNG;
+exports.createMulberry32 = cdp.createMulberry32;
+exports.fnv1a = cdp.fnv1a;
+exports.formatCanonicalHeaders = cdp.formatCanonicalHeaders;
+exports.formatStructuredBrandList = cdp.formatStructuredBrandList;
+exports.generateBrandVersions = cdp.generateBrandVersions;
+exports.generateDevicePassport = cdp.generateDevicePassport;
+exports.generatePassport = cdp.generatePassport;
+exports.generateUserAgentClientHints = cdp.generateUserAgentClientHints;
+exports.getApifyHeadersIfAvailable = cdp.getApifyHeadersIfAvailable;
+exports.getCdpPlan = cdp.getCdpPlan;
+exports.getHardwarePresets = cdp.getHardwarePresets;
+exports.getPixelProtectionConfig = cdp.getPixelProtectionConfig;
+exports.getPixelProtectionScript = cdp.getPixelProtectionScript;
+exports.getPlaywrightContext = cdp.getPlaywrightContext;
+exports.getPuppeteerArgs = cdp.getPuppeteerArgs;
+exports.getStaticFallbackHeaders = cdp.getStaticFallbackHeaders;
+exports.getStealthScript = cdp.getStealthScript;
+exports.murmur3 = cdp.murmur3;
+exports.parseStructuredBrandList = cdp.parseStructuredBrandList;
+exports.toCurl = cdp.toCurl;
+exports.validateHardwareContradictions = cdp.validateHardwareContradictions;
+exports.withPassport = cdp.withPassport;
+exports.BASELINE_OPTIMAL_ENTROPY = evaluator_index.BASELINE_OPTIMAL_ENTROPY;
+exports.BROWSER_BASELINE_FREQUENCIES = evaluator_index.BROWSER_BASELINE_FREQUENCIES;
+exports.COUNTRY_PRIMARY_LANGUAGES = evaluator_index.COUNTRY_PRIMARY_LANGUAGES;
+exports.COUNTRY_TIMEZONE_MAP = evaluator_index.COUNTRY_TIMEZONE_MAP;
+exports.MIN_STRUCTURAL_ENTROPY = evaluator_index.MIN_STRUCTURAL_ENTROPY;
+exports.OPTIMAL_CHAR_ENTROPY_MAX = evaluator_index.OPTIMAL_CHAR_ENTROPY_MAX;
+exports.OPTIMAL_CHAR_ENTROPY_MIN = evaluator_index.OPTIMAL_CHAR_ENTROPY_MIN;
+exports.OPTIMAL_ENTROPY_MAX = evaluator_index.OPTIMAL_ENTROPY_MAX;
+exports.OPTIMAL_ENTROPY_MIN = evaluator_index.OPTIMAL_ENTROPY_MIN;
+exports.analyzeHeaderEntropy = evaluator_index.analyzeHeaderEntropy;
+exports.calculateKLDivergence = evaluator_index.calculateKLDivergence;
+exports.calculateShannonEntropy = evaluator_index.calculateShannonEntropy;
+exports.calculateStructuralEntropy = evaluator_index.calculateStructuralEntropy;
+exports.detectAllContradictions = evaluator_index.detectAllContradictions;
+exports.detectClientHintsContradictions = evaluator_index.detectClientHintsContradictions;
+exports.detectGeoChronoContradictions = evaluator_index.detectGeoChronoContradictions;
+exports.detectHardwareContradictions = evaluator_index.detectHardwareContradictions;
+exports.detectOSBrowserContradictions = evaluator_index.detectOSBrowserContradictions;
+exports.evaluateCoherence = evaluator_index.evaluateCoherence;
+exports.evaluateGeoAlignment = evaluator_index.evaluateGeoAlignment;
+exports.evaluatePassport = evaluator_index.evaluatePassport;
+exports.JSONFileStorage = memory.JSONFileStorage;
+exports.MemoryStorage = memory.MemoryStorage;
+exports.GEO_LOCALES = geo_index.GEO_LOCALES;
+exports.TIMEZONE_MATRIX = geo_index.TIMEZONE_MATRIX;
+exports.detectGeoFromUrl = geo_index.detectGeoFromUrl;
+exports.getLocaleProfile = geo_index.getLocaleProfile;
+exports.isValidCountryCode = geo_index.isValidCountryCode;
+exports.ALPHA3_TO_ALPHA2 = aligner.ALPHA3_TO_ALPHA2;
+exports.COUNTRY_LOCALES = aligner.COUNTRY_LOCALES;
+exports.COUNTRY_NAME_TO_CODE = aligner.COUNTRY_NAME_TO_CODE;
+exports.DEFAULT_ACCEPT_LANGUAGE = aligner.DEFAULT_ACCEPT_LANGUAGE;
+exports.DEFAULT_COUNTRY = aligner.DEFAULT_COUNTRY;
+exports.DEFAULT_LOCALE = aligner.DEFAULT_LOCALE;
+exports.DEFAULT_TIMEZONE = aligner.DEFAULT_TIMEZONE;
+exports.TIMEZONE_TO_COUNTRY = aligner.TIMEZONE_TO_COUNTRY;
+exports.alignGeoContext = aligner.alignGeoContext;
+exports.detectCountry = aligner.detectCountry;
+exports.extractCountryFromProxyUrl = aligner.extractCountryFromProxyUrl;
+exports.formatAcceptLanguage = aligner.formatAcceptLanguage;
+exports.getAllSupportedCountries = aligner.getAllSupportedCountries;
+exports.getCountryConfig = aligner.getCountryConfig;
+exports.getCountryForTimezone = aligner.getCountryForTimezone;
+exports.getDefaultTimezoneForCountry = aligner.getDefaultTimezoneForCountry;
+exports.getTimezoneOffsetMinutes = aligner.getTimezoneOffsetMinutes;
+exports.getTimezonesForCountry = aligner.getTimezonesForCountry;
+exports.hasCountryConfig = aligner.hasCountryConfig;
+exports.isGeoAligned = aligner.isGeoAligned;
+exports.isTimezoneAlignedWithCountry = aligner.isTimezoneAlignedWithCountry;
+exports.isValidTimezone = aligner.isValidTimezone;
+exports.listAllTimezones = aligner.listAllTimezones;
+exports.normalizeCountryCode = aligner.normalizeCountryCode;
+exports.parseAcceptLanguage = aligner.parseAcceptLanguage;
+exports.toGeoLocation = aligner.toGeoLocation;
+exports.toLocaleProfile = aligner.toLocaleProfile;
 exports.BENCHMARK_METRICS_METADATA = BENCHMARK_METRICS_METADATA;
-exports.BROWSER_BASELINE_FREQUENCIES = BROWSER_BASELINE_FREQUENCIES;
-exports.CANONICAL_HEADER_ORDER = CANONICAL_HEADER_ORDER;
-exports.CHROME_VERSIONS = CHROME_VERSIONS;
 exports.COMPARATIVE_DATASET = COMPARATIVE_DATASET;
-exports.COUNTRY_LOCALES = COUNTRY_LOCALES;
-exports.COUNTRY_NAME_TO_CODE = COUNTRY_NAME_TO_CODE;
-exports.COUNTRY_PRIMARY_LANGUAGES = COUNTRY_PRIMARY_LANGUAGES;
-exports.COUNTRY_TIMEZONE_MAP = COUNTRY_TIMEZONE_MAP;
-exports.DEFAULT_ACCEPT_LANGUAGE = DEFAULT_ACCEPT_LANGUAGE;
-exports.DEFAULT_COUNTRY = DEFAULT_COUNTRY;
-exports.DEFAULT_LOCALE = DEFAULT_LOCALE;
-exports.DEFAULT_TIMEZONE = DEFAULT_TIMEZONE;
 exports.DevicePassportInstance = DevicePassportInstance;
-exports.EDGE_VERSIONS = EDGE_VERSIONS;
-exports.GEO_LOCALES = GEO_LOCALES;
-exports.JSONFileStorage = JSONFileStorage;
-exports.MACOS_PRESETS = MACOS_PRESETS;
-exports.MIN_STRUCTURAL_ENTROPY = MIN_STRUCTURAL_ENTROPY;
-exports.MemoryStorage = MemoryStorage;
-exports.OPTIMAL_CHAR_ENTROPY_MAX = OPTIMAL_CHAR_ENTROPY_MAX;
-exports.OPTIMAL_CHAR_ENTROPY_MIN = OPTIMAL_CHAR_ENTROPY_MIN;
-exports.OPTIMAL_ENTROPY_MAX = OPTIMAL_ENTROPY_MAX;
-exports.OPTIMAL_ENTROPY_MIN = OPTIMAL_ENTROPY_MIN;
 exports.PassportManager = PassportManager;
-exports.TIMEZONE_MATRIX = TIMEZONE_MATRIX;
-exports.TIMEZONE_TO_COUNTRY = TIMEZONE_TO_COUNTRY;
 exports.VERSION = VERSION;
-exports.WINDOWS_PRESETS = WINDOWS_PRESETS;
-exports.alignGeoContext = alignGeoContext;
-exports.analyzeHeaderEntropy = analyzeHeaderEntropy;
-exports.applyToPlaywrightContext = applyToPlaywrightContext;
-exports.applyToPuppeteerPage = applyToPuppeteerPage;
-exports.buildUserAgent = buildUserAgent;
-exports.calculateKLDivergence = calculateKLDivergence;
-exports.calculateShannonEntropy = calculateShannonEntropy;
-exports.calculateStructuralEntropy = calculateStructuralEntropy;
-exports.createDeterministicPRNG = createDeterministicPRNG;
-exports.createMulberry32 = createMulberry32;
 exports.createPassport = createPassport;
-exports.detectAllContradictions = detectAllContradictions;
-exports.detectClientHintsContradictions = detectClientHintsContradictions;
-exports.detectCountry = detectCountry;
-exports.detectGeoChronoContradictions = detectGeoChronoContradictions;
-exports.detectGeoFromUrl = detectGeoFromUrl;
-exports.detectHardwareContradictions = detectHardwareContradictions;
-exports.detectOSBrowserContradictions = detectOSBrowserContradictions;
-exports.evaluateCoherence = evaluateCoherence;
-exports.evaluateGeoAlignment = evaluateGeoAlignment;
-exports.evaluatePassport = evaluatePassport;
-exports.extractCountryFromProxyUrl = extractCountryFromProxyUrl;
-exports.fnv1a = fnv1a;
-exports.formatAcceptLanguage = formatAcceptLanguage;
-exports.formatCanonicalHeaders = formatCanonicalHeaders;
 exports.formatComparativeMatrixJSON = formatComparativeMatrixJSON;
 exports.formatComparativeMatrixLaTeX = formatComparativeMatrixLaTeX;
 exports.formatComparativeMatrixMarkdown = formatComparativeMatrixMarkdown;
-exports.formatStructuredBrandList = formatStructuredBrandList;
-exports.generateBrandVersions = generateBrandVersions;
-exports.generateDevicePassport = generateDevicePassport;
-exports.generatePassport = generatePassport;
-exports.generateUserAgentClientHints = generateUserAgentClientHints;
-exports.getAllSupportedCountries = getAllSupportedCountries;
-exports.getApifyHeadersIfAvailable = getApifyHeadersIfAvailable;
-exports.getCountryConfig = getCountryConfig;
-exports.getCountryForTimezone = getCountryForTimezone;
-exports.getDefaultTimezoneForCountry = getDefaultTimezoneForCountry;
-exports.getHardwarePresets = getHardwarePresets;
-exports.getLocaleProfile = getLocaleProfile;
-exports.getPlaywrightContext = getPlaywrightContext;
-exports.getPuppeteerArgs = getPuppeteerArgs;
-exports.getStaticFallbackHeaders = getStaticFallbackHeaders;
-exports.getStealthScript = getStealthScript;
-exports.getTimezoneOffsetMinutes = getTimezoneOffsetMinutes;
-exports.getTimezonesForCountry = getTimezonesForCountry;
-exports.hasCountryConfig = hasCountryConfig;
-exports.isGeoAligned = isGeoAligned;
-exports.isTimezoneAlignedWithCountry = isTimezoneAlignedWithCountry;
-exports.isValidCountryCode = isValidCountryCode;
-exports.isValidTimezone = isValidTimezone;
-exports.listAllTimezones = listAllTimezones;
-exports.murmur3 = murmur3;
-exports.normalizeCountryCode = normalizeCountryCode;
-exports.parseAcceptLanguage = parseAcceptLanguage;
-exports.parseStructuredBrandList = parseStructuredBrandList;
 exports.runComparativeBenchmark = runComparativeBenchmark;
-exports.toCurl = toCurl;
-exports.toGeoLocation = toGeoLocation;
-exports.toLocaleProfile = toLocaleProfile;
-exports.validateHardwareContradictions = validateHardwareContradictions;
-exports.withPassport = withPassport;