device-passport 1.1.0 → 1.2.0

package/dist/evaluator/index.cjs

@@ -1,571 +1,9 @@
 '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))
-    }
-  };
-}
+const entropy = require('../shared/device-passport.EK4RX7Xd.cjs');
 
 function evaluateGeoAlignment(passport) {
-  const geoContradictions = detectGeoChronoContradictions(passport);
+  const geoContradictions = entropy.detectGeoChronoContradictions(passport);
   let score = 100;
   for (const c of geoContradictions) {
     score -= c.impactPenalty;
@@ -581,9 +19,9 @@ function evaluateGeoAlignment(passport) {
   return Math.max(0, Math.min(100, score));
 }
 function evaluateCoherence(passport) {
-  const contradictions = detectAllContradictions(passport);
+  const contradictions = entropy.detectAllContradictions(passport);
   const geoAlignmentScore = evaluateGeoAlignment(passport);
-  const entropyResult = analyzeHeaderEntropy(passport.headers || {});
+  const entropyResult = entropy.analyzeHeaderEntropy(passport.headers || {});
   const entropyScore = entropyResult.entropyScore;
   let totalPenalty = 0;
   let fatalCount = 0;
@@ -679,24 +117,24 @@ function evaluatePassport(passport) {
   return evaluateCoherence(passport);
 }
 
-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;
+exports.BASELINE_OPTIMAL_ENTROPY = entropy.BASELINE_OPTIMAL_ENTROPY;
+exports.BROWSER_BASELINE_FREQUENCIES = entropy.BROWSER_BASELINE_FREQUENCIES;
+exports.COUNTRY_PRIMARY_LANGUAGES = entropy.COUNTRY_PRIMARY_LANGUAGES;
+exports.COUNTRY_TIMEZONE_MAP = entropy.COUNTRY_TIMEZONE_MAP;
+exports.MIN_STRUCTURAL_ENTROPY = entropy.MIN_STRUCTURAL_ENTROPY;
+exports.OPTIMAL_CHAR_ENTROPY_MAX = entropy.OPTIMAL_CHAR_ENTROPY_MAX;
+exports.OPTIMAL_CHAR_ENTROPY_MIN = entropy.OPTIMAL_CHAR_ENTROPY_MIN;
+exports.OPTIMAL_ENTROPY_MAX = entropy.OPTIMAL_ENTROPY_MAX;
+exports.OPTIMAL_ENTROPY_MIN = entropy.OPTIMAL_ENTROPY_MIN;
+exports.analyzeHeaderEntropy = entropy.analyzeHeaderEntropy;
+exports.calculateKLDivergence = entropy.calculateKLDivergence;
+exports.calculateShannonEntropy = entropy.calculateShannonEntropy;
+exports.calculateStructuralEntropy = entropy.calculateStructuralEntropy;
+exports.detectAllContradictions = entropy.detectAllContradictions;
+exports.detectClientHintsContradictions = entropy.detectClientHintsContradictions;
+exports.detectGeoChronoContradictions = entropy.detectGeoChronoContradictions;
+exports.detectHardwareContradictions = entropy.detectHardwareContradictions;
+exports.detectOSBrowserContradictions = entropy.detectOSBrowserContradictions;
 exports.evaluateCoherence = evaluateCoherence;
 exports.evaluateGeoAlignment = evaluateGeoAlignment;
 exports.evaluatePassport = evaluatePassport;