device-passport 1.0.0 → 1.2.0

package/dist/shared/device-passport.EK4RX7Xd.cjs

@@ -0,0 +1,584 @@
+'use strict';
+
+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))
+    }
+  };
+}
+
+exports.BASELINE_OPTIMAL_ENTROPY = BASELINE_OPTIMAL_ENTROPY;
+exports.BROWSER_BASELINE_FREQUENCIES = BROWSER_BASELINE_FREQUENCIES;
+exports.COUNTRY_PRIMARY_LANGUAGES = COUNTRY_PRIMARY_LANGUAGES;
+exports.COUNTRY_TIMEZONE_MAP = COUNTRY_TIMEZONE_MAP;
+exports.MIN_STRUCTURAL_ENTROPY = MIN_STRUCTURAL_ENTROPY;
+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.analyzeHeaderEntropy = analyzeHeaderEntropy;
+exports.calculateKLDivergence = calculateKLDivergence;
+exports.calculateShannonEntropy = calculateShannonEntropy;
+exports.calculateStructuralEntropy = calculateStructuralEntropy;
+exports.detectAllContradictions = detectAllContradictions;
+exports.detectClientHintsContradictions = detectClientHintsContradictions;
+exports.detectGeoChronoContradictions = detectGeoChronoContradictions;
+exports.detectHardwareContradictions = detectHardwareContradictions;
+exports.detectOSBrowserContradictions = detectOSBrowserContradictions;

package/dist/shared/device-passport.ZBspe4ZW.d.mts

@@ -0,0 +1,77 @@
+import { DevicePassport } from '../types/index.mjs';
+
+interface PlaywrightContextOptions {
+    userAgent: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    deviceScaleFactor: number;
+    locale: string;
+    timezoneId: string;
+    geolocation?: {
+        latitude: number;
+        longitude: number;
+        accuracy?: number;
+    };
+    permissions?: string[];
+    extraHTTPHeaders: Record<string, string>;
+    hasTouch: boolean;
+    isMobile: boolean;
+    colorScheme?: 'light' | 'dark' | 'no-preference';
+}
+/**
+ * Builds Playwright BrowserContext options directly from a DevicePassport.
+ * Ready for `browser.newContext(getPlaywrightContext(passport))`.
+ */
+declare function getPlaywrightContext(passport: DevicePassport): PlaywrightContextOptions;
+/**
+ * Generates an in-page stealth script to patch runtime JavaScript APIs
+ * (navigator.webdriver, hardwareConcurrency, deviceMemory, WebGL unmasked vendor/renderer,
+ * navigator.userAgentData Client Hints, and Screen dimensions).
+ *
+ * 🔴 API-level spoofing is not enough on its own: `canvas.toDataURL()` and `gl.readPixels()`
+ * still return the **real** framebuffer, so a headless browser exposes SwiftShader while
+ * its UA claims a discrete GPU — and every persona on one machine hashes identically.
+ * The pixel-protection script is therefore appended here, so existing users get
+ * read-back-safe personas without changing their call sites.
+ *
+ * The noise is seeded from the passport seed: stable per account, different per account.
+ */
+declare function getStealthScript(passport: DevicePassport): string;
+/**
+ * Applies stealth injections and extra headers to a Playwright BrowserContext.
+ *
+ * @param context Playwright BrowserContext instance
+ * @param passport DevicePassport instance
+ */
+declare function applyToPlaywrightContext(context: any, passport: DevicePassport): Promise<void>;
+
+interface PuppeteerEmulationOptions {
+    launchArgs: string[];
+    defaultViewport: {
+        width: number;
+        height: number;
+        deviceScaleFactor: number;
+        isMobile: boolean;
+        hasTouch: boolean;
+    };
+    userAgent: string;
+    locale: string;
+    timezoneId: string;
+    extraHTTPHeaders: Record<string, string>;
+}
+/**
+ * Returns Puppeteer launch args and page emulation parameters matching the DevicePassport.
+ */
+declare function getPuppeteerArgs(passport: DevicePassport): PuppeteerEmulationOptions;
+/**
+ * Applies stealth injections, headers, viewport, and timezone emulation to a Puppeteer Page.
+ *
+ * @param page Puppeteer Page instance
+ * @param passport DevicePassport instance
+ */
+declare function applyToPuppeteerPage(page: any, passport: DevicePassport): Promise<void>;
+
+export { applyToPlaywrightContext as b, applyToPuppeteerPage as c, getPuppeteerArgs as d, getStealthScript as e, getPlaywrightContext as g };
+export type { PlaywrightContextOptions as P, PuppeteerEmulationOptions as a };