@ianmenethil/zp-devicefp 0.1.0-alpha.0

package/dist/cdn/zp.dfp.esm.js

@@ -0,0 +1,1449 @@
+// src/runtime/browser.ts
+function getBrowserEnv() {
+  return {
+    global: globalThis,
+    navigator: typeof navigator === "undefined" ? void 0 : navigator,
+    document: typeof document === "undefined" ? void 0 : document,
+    screen: typeof screen === "undefined" ? void 0 : screen,
+    location: typeof location === "undefined" ? void 0 : location,
+    fetch: typeof fetch === "undefined" ? void 0 : fetch,
+    crypto: globalThis.crypto,
+    performance: typeof performance === "undefined" ? void 0 : performance,
+    intl: typeof Intl === "undefined" ? void 0 : Intl
+  };
+}
+function now(env) {
+  return env.performance?.now?.() ?? Date.now();
+}
+function hasDom(env) {
+  return Boolean(env.document?.createElement);
+}
+function hasCanvas(env) {
+  return Boolean(env.document?.createElement?.("canvas").getContext);
+}
+
+// src/signals/audio.ts
+function getOfflineAudioContext(env) {
+  const g = env;
+  return g.OfflineAudioContext ?? g.webkitOfflineAudioContext;
+}
+var audioCollector = {
+  name: "audio",
+  tier: "core",
+  supportsSync: false,
+  async collect(context) {
+    const started = now(context.env);
+    const OfflineContext = getOfflineAudioContext(context.env.global);
+    if (!OfflineContext) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    try {
+      const audioContext = new OfflineContext(1, 5e3, 44100);
+      const oscillator = audioContext.createOscillator();
+      const compressor = audioContext.createDynamicsCompressor();
+      oscillator.type = "triangle";
+      oscillator.frequency.value = 1e4;
+      compressor.threshold.value = -50;
+      compressor.knee.value = 40;
+      compressor.ratio.value = 12;
+      compressor.attack.value = 0;
+      compressor.release.value = 0.25;
+      oscillator.connect(compressor);
+      compressor.connect(audioContext.destination);
+      oscillator.start(0);
+      const rendered = await audioContext.startRendering();
+      const channelData = rendered.getChannelData(0);
+      let sum = 0;
+      for (let i = 4500; i < channelData.length; i += 1) {
+        sum += Math.abs(channelData[i]);
+      }
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: {
+          sampleRate: rendered.sampleRate,
+          length: rendered.length,
+          signalValue: Number(sum.toFixed(6))
+        }
+      };
+    } catch (error) {
+      return {
+        status: "blocked",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/signals/canvas.ts
+function renderCanvasFingerprint(doc) {
+  const canvas = doc.createElement("canvas");
+  canvas.width = 280;
+  canvas.height = 80;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("2D canvas context unavailable");
+  }
+  ctx.fillStyle = "#f60";
+  ctx.fillRect(8, 10, 120, 60);
+  ctx.fillStyle = "#069";
+  ctx.font = "20px Arial";
+  ctx.fillText("Browser FP", 12, 40);
+  ctx.strokeStyle = "rgba(102, 204, 0, 0.7)";
+  ctx.beginPath();
+  ctx.arc(180, 40, 24, 0, Math.PI * 2);
+  ctx.stroke();
+  return {
+    dataUrl: canvas.toDataURL(),
+    winding: ctx.isPointInPath(1, 1, "evenodd")
+  };
+}
+var canvasCollector = {
+  name: "canvas",
+  tier: "core",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const doc = context.env.document;
+    if (!doc || !hasCanvas(context.env)) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    try {
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: renderCanvasFingerprint(doc)
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/constants.ts
+var CORE_SIGNALS = ["ua", "uaHints", "locale", "screen", "hardware", "storage", "fonts", "canvas", "webgl", "audio"];
+var EXTENDED_SIGNALS = [
+  "mediaDevices",
+  "permissions",
+  "webrtc",
+  "frameInfo",
+  "networkInfo",
+  "paymentSupport",
+  "referrerInfo",
+  "navigationInfo",
+  "riskSignals"
+];
+var SYNC_SIGNALS = [
+  "ua",
+  "locale",
+  "screen",
+  "hardware",
+  "storage",
+  "fonts",
+  "canvas",
+  "webgl",
+  "frameInfo",
+  "networkInfo",
+  "paymentSupport",
+  "referrerInfo",
+  "navigationInfo"
+];
+var DEFAULT_TIMEOUT_MS = 1500;
+var DEFAULT_FONT_LIST = [
+  "Arial",
+  "Helvetica Neue",
+  "Times New Roman",
+  "Georgia",
+  "Courier New",
+  "Trebuchet MS",
+  "Verdana",
+  "Tahoma",
+  "Impact",
+  "Comic Sans MS"
+];
+var DEFAULT_PERMISSION_NAMES = ["geolocation", "notifications", "camera", "microphone"];
+var DEFAULT_UA_HINTS = [
+  "architecture",
+  "bitness",
+  "formFactors",
+  "fullVersionList",
+  "model",
+  "platform",
+  "platformVersion",
+  "wow64"
+];
+
+// src/signals/fonts.ts
+var GENERIC_FAMILIES = ["monospace", "sans-serif", "serif"];
+var TEST_TEXT = "mmmmmmmmmmlli";
+function measureText(doc, fontFamily, genericFamily) {
+  const span = doc.createElement("span");
+  span.textContent = TEST_TEXT;
+  span.style.position = "absolute";
+  span.style.left = "-9999px";
+  span.style.top = "-9999px";
+  span.style.fontSize = "72px";
+  span.style.fontFamily = `${fontFamily}, ${genericFamily}`;
+  doc.body.appendChild(span);
+  const width = span.offsetWidth;
+  doc.body.removeChild(span);
+  return width;
+}
+function collectFontMatches(doc) {
+  const matches = [];
+  for (const candidate of DEFAULT_FONT_LIST) {
+    let detected = false;
+    for (const generic of GENERIC_FAMILIES) {
+      const baseWidth = measureText(doc, "", generic);
+      const candidateWidth = measureText(doc, candidate, generic);
+      if (candidateWidth !== baseWidth) {
+        detected = true;
+        break;
+      }
+    }
+    if (detected) {
+      matches.push(candidate);
+    }
+  }
+  return matches;
+}
+var fontsCollector = {
+  name: "fonts",
+  tier: "core",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const doc = context.env.document;
+    if (!doc || !hasDom(context.env)) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    try {
+      const fonts = collectFontMatches(doc);
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: {
+          detectedFonts: fonts,
+          fontCount: fonts.length
+        }
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/signals/frameInfo.ts
+var frameInfoCollector = {
+  name: "frameInfo",
+  tier: "extended",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const doc = context.env.document;
+    if (!doc) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    try {
+      const iframes = doc.getElementsByTagName("iframe");
+      const domains = [];
+      for (const element of iframes) {
+        const src = element.src || "";
+        try {
+          domains.push(new URL(src).hostname);
+        } catch {
+          domains.push("unknown");
+        }
+      }
+      const win = context.env.global;
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: {
+          iframesCount: iframes.length,
+          isTopLevel: win === win.top,
+          iframeDomains: domains
+        }
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/signals/hardware.ts
+var hardwareCollector = {
+  name: "hardware",
+  tier: "core",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const nav = context.env.navigator;
+    if (!nav) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    return {
+      status: "ok",
+      durationMs: now(context.env) - started,
+      value: {
+        hardwareConcurrency: nav.hardwareConcurrency,
+        deviceMemory: nav.deviceMemory,
+        platform: nav.platform,
+        maxTouchPoints: nav.maxTouchPoints
+      }
+    };
+  }
+};
+
+// src/signals/locale.ts
+var localeCollector = {
+  name: "locale",
+  tier: "core",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const nav = context.env.navigator;
+    const intl = context.env.intl;
+    if (!nav || !intl) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    const formatter = new intl.DateTimeFormat();
+    const options = formatter.resolvedOptions();
+    const numberFormatter = new intl.NumberFormat(nav.language);
+    const relativeTimeFormatter = typeof intl.RelativeTimeFormat === "function" ? new intl.RelativeTimeFormat(nav.language, { numeric: "auto" }) : void 0;
+    const sampleDate = new Date(Date.UTC(2024, 0, 2, 3, 4, 5));
+    return {
+      status: "ok",
+      durationMs: now(context.env) - started,
+      value: {
+        language: nav.language,
+        languages: nav.languages,
+        locale: options.locale,
+        calendar: options.calendar,
+        numberingSystem: options.numberingSystem,
+        timeZone: options.timeZone,
+        hourCycle: options.hourCycle,
+        timeZoneOffsetMinutes: sampleDate.getTimezoneOffset(),
+        formattedNumber: numberFormatter.format(123456.789),
+        formattedDate: formatter.format(sampleDate),
+        formattedRelativeDay: relativeTimeFormatter?.format(-1, "day")
+      }
+    };
+  }
+};
+
+// src/signals/mediaDevices.ts
+var mediaDevicesCollector = {
+  name: "mediaDevices",
+  tier: "extended",
+  supportsSync: false,
+  async collect(context) {
+    const started = now(context.env);
+    const mediaDevices = context.env.navigator?.mediaDevices;
+    const runtime = context.env.global;
+    if (!runtime.isSecureContext) {
+      return {
+        status: "blocked",
+        durationMs: now(context.env) - started,
+        error: "Media device enumeration requires a secure context."
+      };
+    }
+    if (runtime.document?.visibilityState !== "visible") {
+      return {
+        status: "blocked",
+        durationMs: now(context.env) - started,
+        error: "Media device enumeration requires a visible document."
+      };
+    }
+    if (!mediaDevices?.enumerateDevices) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    try {
+      const devices = await mediaDevices.enumerateDevices();
+      const summary = devices.reduce((acc, device) => {
+        acc[device.kind] = (acc[device.kind] ?? 0) + 1;
+        return acc;
+      }, {});
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: summary
+      };
+    } catch (error) {
+      return {
+        status: "blocked",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/signals/navigationInfo.ts
+var navigationInfoCollector = {
+  name: "navigationInfo",
+  tier: "extended",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const perf = context.env.performance;
+    if (!perf) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    try {
+      let navType = null;
+      const entries = perf.getEntriesByType("navigation");
+      const navEntry = entries?.[0];
+      if (navEntry !== void 0) {
+        navType = navEntry.type;
+      }
+      if (navType === null) {
+        navType = perf.navigation.type;
+      }
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: { navigationType: navType }
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/signals/networkInfo.ts
+var networkInfoCollector = {
+  name: "networkInfo",
+  tier: "extended",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const nav = context.env.navigator;
+    if (!nav) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    const conn = nav.connection ?? nav.mozConnection ?? nav.webkitConnection ?? null;
+    if (!conn) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    const c = conn;
+    return {
+      status: "ok",
+      durationMs: now(context.env) - started,
+      value: {
+        effectiveType: c.effectiveType ?? null,
+        downlink: c.downlink ?? null,
+        rtt: c.rtt ?? null,
+        saveData: typeof c.saveData === "boolean" ? c.saveData : null
+      }
+    };
+  }
+};
+
+// src/signals/paymentSupport.ts
+var paymentSupportCollector = {
+  name: "paymentSupport",
+  tier: "extended",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const win = context.env.global;
+    return {
+      status: "ok",
+      durationMs: now(context.env) - started,
+      value: {
+        paymentRequest: win.PaymentRequest !== void 0
+      }
+    };
+  }
+};
+
+// src/signals/permissions.ts
+var permissionsCollector = {
+  name: "permissions",
+  tier: "extended",
+  supportsSync: false,
+  async collect(context) {
+    const started = now(context.env);
+    const permissions = context.env.navigator?.permissions;
+    if (!permissions?.query) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    try {
+      const results = await Promise.all(
+        DEFAULT_PERMISSION_NAMES.map(async (name) => {
+          try {
+            const state = await permissions.query({ name });
+            return [name, state.state];
+          } catch {
+            return [name, "unsupported"];
+          }
+        })
+      );
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: Object.fromEntries(results)
+      };
+    } catch (error) {
+      return {
+        status: "blocked",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/signals/referrerInfo.ts
+var referrerInfoCollector = {
+  name: "referrerInfo",
+  tier: "extended",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const doc = context.env.document;
+    if (!doc) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    return {
+      status: "ok",
+      durationMs: now(context.env) - started,
+      value: { referrer: doc.referrer }
+    };
+  }
+};
+
+// src/signals/riskSignals.ts
+var riskSignalsCollector = {
+  name: "riskSignals",
+  tier: "extended",
+  supportsSync: false,
+  async collect(context) {
+    const started = now(context.env);
+    const nav = context.env.navigator;
+    const win = context.env.global;
+    if (!nav) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    try {
+      const ua = nav.userAgent;
+      const webdriver = nav.webdriver ? true : null;
+      const hints = [];
+      if (ua.includes("HeadlessChrome")) {
+        hints.push("headless-ua");
+      }
+      if (ua.includes("Chrome") && typeof win.chrome !== "object") {
+        hints.push("missing-chrome-object");
+      }
+      if (win.outerHeight === 0 || win.outerWidth === 0) {
+        hints.push("zero-outer-dimensions");
+      }
+      if (ua.includes("Chrome") && !ua.includes("Mobile") && nav.plugins.length === 0) {
+        hints.push("no-plugins-on-desktop-chrome");
+      }
+      if (Array.isArray(nav.languages) && nav.languages.length === 0) {
+        hints.push("empty-languages");
+      }
+      let uaConsistency = null;
+      const userAgentData = nav.userAgentData;
+      if (userAgentData && "getHighEntropyValues" in userAgentData) {
+        try {
+          const uad = userAgentData;
+          const uaPlatform = ua.includes("Win") ? "Windows" : ua.includes("Mac") ? "macOS" : ua.includes("Linux") ? "Linux" : null;
+          const uadPlatform = uad.platform || null;
+          uaConsistency = uaPlatform === null || uadPlatform === null ? null : uaPlatform === uadPlatform;
+        } catch {
+          uaConsistency = null;
+        }
+      }
+      const notificationPermission = typeof Notification !== "undefined" ? Notification.permission : null;
+      let permissionsHeadlessHint = null;
+      if (typeof nav.permissions?.query === "function") {
+        try {
+          const status = await nav.permissions.query({ name: "notifications" });
+          if (status.state === "denied" && Notification.permission === "default") {
+            permissionsHeadlessHint = true;
+          }
+        } catch {
+          permissionsHeadlessHint = null;
+        }
+      }
+      const timeToCaptureMs = context.env.performance?.timeOrigin ? Math.round(Date.now() - context.env.performance.timeOrigin) : null;
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: {
+          webdriver,
+          headlessHints: hints,
+          uaConsistency,
+          notificationPermission,
+          permissionsHeadlessHint,
+          timeToCaptureMs
+        }
+      };
+    } catch (error) {
+      return {
+        status: "blocked",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/signals/screen.ts
+function getMediaPreference(runtime, query) {
+  if (typeof runtime.matchMedia !== "function") {
+    return "unsupported";
+  }
+  try {
+    return runtime.matchMedia(query).matches;
+  } catch {
+    return "unsupported";
+  }
+}
+var screenCollector = {
+  name: "screen",
+  tier: "core",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const screen2 = context.env.screen;
+    const nav = context.env.navigator;
+    const runtime = context.env.global;
+    if (!screen2) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    return {
+      status: "ok",
+      durationMs: now(context.env) - started,
+      value: {
+        width: screen2.width,
+        height: screen2.height,
+        availWidth: screen2.availWidth,
+        availHeight: screen2.availHeight,
+        colorDepth: screen2.colorDepth,
+        pixelDepth: screen2.pixelDepth,
+        orientationType: screen2.orientation.type,
+        orientationAngle: screen2.orientation.angle,
+        maxTouchPoints: nav?.maxTouchPoints ?? 0,
+        devicePixelRatio: typeof runtime.devicePixelRatio === "number" ? runtime.devicePixelRatio : void 0,
+        colorGamutP3: getMediaPreference(runtime, "(color-gamut: p3)"),
+        prefersReducedMotion: getMediaPreference(runtime, "(prefers-reduced-motion: reduce)"),
+        prefersContrastMore: getMediaPreference(runtime, "(prefers-contrast: more)"),
+        forcedColorsActive: getMediaPreference(runtime, "(forced-colors: active)")
+      }
+    };
+  }
+};
+
+// src/signals/storage.ts
+function checkStorageFromGlobal(runtime, name) {
+  try {
+    const target = runtime[name];
+    if (!target) {
+      return "unsupported";
+    }
+    const key = "__bf_probe__";
+    target.setItem(key, "1");
+    target.removeItem(key);
+    return "available";
+  } catch {
+    return "blocked";
+  }
+}
+var storageCollector = {
+  name: "storage",
+  tier: "core",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const nav = context.env.navigator;
+    const runtime = context.env.global;
+    return {
+      status: "ok",
+      durationMs: now(context.env) - started,
+      value: {
+        cookiesEnabled: nav?.cookieEnabled ?? false,
+        localStorage: checkStorageFromGlobal(runtime, "localStorage"),
+        sessionStorage: checkStorageFromGlobal(runtime, "sessionStorage"),
+        indexedDb: typeof runtime.indexedDB === "undefined" ? "unsupported" : "available",
+        openDatabase: typeof runtime.openDatabase === "undefined" ? "unsupported" : "available",
+        pdfViewerEnabled: nav?.pdfViewerEnabled ?? false
+      }
+    };
+  }
+};
+
+// src/signals/ua.ts
+var uaCollector = {
+  name: "ua",
+  tier: "core",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const nav = context.env.navigator;
+    if (!nav) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    return {
+      status: "ok",
+      durationMs: now(context.env) - started,
+      value: {
+        userAgent: nav.userAgent,
+        appVersion: nav.appVersion,
+        vendor: nav.vendor,
+        platform: nav.platform,
+        webdriver: nav.webdriver,
+        maxTouchPoints: nav.maxTouchPoints,
+        cookieEnabled: nav.cookieEnabled,
+        vendorSub: nav.vendorSub
+      }
+    };
+  }
+};
+
+// src/signals/uaHints.ts
+var uaHintsCollector = {
+  name: "uaHints",
+  tier: "core",
+  supportsSync: false,
+  async collect(context) {
+    const started = now(context.env);
+    const userAgentData = context.env.navigator?.userAgentData;
+    if (!userAgentData) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    try {
+      const highEntropy = userAgentData.getHighEntropyValues ? await userAgentData.getHighEntropyValues([...DEFAULT_UA_HINTS]) : void 0;
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: {
+          brands: userAgentData.brands ?? [],
+          mobile: Boolean(userAgentData.mobile),
+          platform: userAgentData.platform,
+          ...highEntropy
+        }
+      };
+    } catch (error) {
+      return {
+        status: "blocked",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/signals/webgl.ts
+function getWebGlContext(doc) {
+  const canvas = doc.createElement("canvas");
+  return canvas.getContext("webgl") ?? canvas.getContext("experimental-webgl");
+}
+var webglCollector = {
+  name: "webgl",
+  tier: "core",
+  supportsSync: true,
+  // eslint-disable-next-line @typescript-eslint/require-await -- Interface requires Promise return; delegates synchronously.
+  async collect(context) {
+    return this.collectSync(context);
+  },
+  collectSync(context) {
+    const started = now(context.env);
+    const doc = context.env.document;
+    if (!doc || !hasCanvas(context.env)) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    const gl = getWebGlContext(doc);
+    if (!gl) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    const debugExtension = gl.getExtension("WEBGL_debug_renderer_info");
+    const renderer = debugExtension ? gl.getParameter(debugExtension.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER);
+    const vendor = debugExtension ? gl.getParameter(debugExtension.UNMASKED_VENDOR_WEBGL) : gl.getParameter(gl.VENDOR);
+    return {
+      status: "ok",
+      durationMs: now(context.env) - started,
+      value: {
+        vendor,
+        renderer,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        version: gl.getParameter(gl.VERSION),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        shadingLanguageVersion: gl.getParameter(gl.SHADING_LANGUAGE_VERSION),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        maxViewportDims: gl.getParameter(gl.MAX_VIEWPORT_DIMS),
+        extensions: gl.getSupportedExtensions() ?? []
+      }
+    };
+  }
+};
+
+// src/signals/webrtc.ts
+function extractSdpSummary(sdp) {
+  const codecs = /* @__PURE__ */ new Set();
+  const extmaps = /* @__PURE__ */ new Set();
+  for (const line of sdp.split(/\r?\n/)) {
+    if (line.startsWith("a=rtpmap:")) {
+      const payload = line.slice("a=rtpmap:".length);
+      codecs.add(payload.split(" ", 2)[1] ?? line);
+    }
+    if (line.startsWith("a=extmap:")) {
+      extmaps.add(line.slice("a=extmap:".length));
+    }
+  }
+  return {
+    codecs: [...codecs].sort(),
+    extmaps: [...extmaps].sort()
+  };
+}
+var webrtcCollector = {
+  name: "webrtc",
+  tier: "extended",
+  supportsSync: false,
+  async collect(context) {
+    const started = now(context.env);
+    const g = context.env.global;
+    const PeerConnection = g.RTCPeerConnection ?? g.webkitRTCPeerConnection;
+    if (!PeerConnection) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    let peer;
+    try {
+      peer = new PeerConnection();
+      peer.createDataChannel("bf");
+      const offer = await peer.createOffer();
+      const summary = extractSdpSummary(offer.sdp ?? "");
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: summary
+      };
+    } catch (error) {
+      return {
+        status: "blocked",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    } finally {
+      peer?.close();
+    }
+  }
+};
+
+// src/signals/index.ts
+var signalCollectors = [
+  uaCollector,
+  uaHintsCollector,
+  localeCollector,
+  screenCollector,
+  hardwareCollector,
+  storageCollector,
+  fontsCollector,
+  canvasCollector,
+  webglCollector,
+  audioCollector,
+  mediaDevicesCollector,
+  permissionsCollector,
+  webrtcCollector,
+  frameInfoCollector,
+  networkInfoCollector,
+  paymentSupportCollector,
+  referrerInfoCollector,
+  navigationInfoCollector,
+  riskSignalsCollector
+];
+var collectorMap = new Map(signalCollectors.map((collector) => [collector.name, collector]));
+
+// src/core/antiSpoof.ts
+function asRecord(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function analyseSignals(signals) {
+  const anomalies = [];
+  const automationHints = [];
+  const ua = asRecord(signals.ua?.value);
+  const uaHints = asRecord(signals.uaHints?.value);
+  const hardware = asRecord(signals.hardware?.value);
+  const screen2 = asRecord(signals.screen?.value);
+  const userAgent = asString(ua?.userAgent)?.toLowerCase() ?? "";
+  const platform = asString(ua?.platform)?.toLowerCase() ?? "";
+  const hintPlatform = asString(uaHints?.platform)?.toLowerCase() ?? "";
+  const webdriver = Boolean(ua?.webdriver);
+  const maxTouchPoints = asNumber(screen2?.maxTouchPoints) ?? asNumber(ua?.maxTouchPoints) ?? 0;
+  const width = asNumber(screen2?.width) ?? 0;
+  const height = asNumber(screen2?.height) ?? 0;
+  const deviceMemory = asNumber(hardware?.deviceMemory);
+  if (webdriver) {
+    automationHints.push("navigator_webdriver");
+  }
+  if (userAgent.includes("headless")) {
+    automationHints.push("headless_user_agent");
+  }
+  if (platform && hintPlatform && !platform.includes(hintPlatform) && !hintPlatform.includes(platform)) {
+    anomalies.push("ua_platform_mismatch");
+  }
+  if (userAgent.includes("iphone") && maxTouchPoints === 0) {
+    anomalies.push("touch_claim_without_touch_points");
+  }
+  if (userAgent.includes("android") && width > 0 && width >= 1600) {
+    anomalies.push("mobile_ua_desktop_screen");
+  }
+  if (userAgent.includes("windows") && platform.includes("mac")) {
+    anomalies.push("windows_ua_mac_platform");
+  }
+  if (deviceMemory !== void 0 && (deviceMemory < 0.25 || deviceMemory > 64)) {
+    anomalies.push("implausible_device_memory");
+  }
+  if (width > 0 && height > 0 && width < 200 && height < 200) {
+    anomalies.push("tiny_screen_geometry");
+  }
+  const anomalyPenalty = anomalies.length * 0.12;
+  const automationPenalty = automationHints.length * 0.18;
+  const score = Math.max(0, Math.min(1, Number((1 - anomalyPenalty - automationPenalty).toFixed(3))));
+  return {
+    score,
+    anomalies,
+    automationHints
+  };
+}
+
+// src/core/canonicalize.ts
+function normalizeNumber(value) {
+  if (!Number.isFinite(value)) {
+    return value;
+  }
+  return Number(value.toFixed(6));
+}
+function canonicalizeInner(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "number") {
+    return normalizeNumber(value);
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => canonicalizeInner(entry));
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "object") {
+    const input = value;
+    const output = {};
+    for (const key of Object.keys(input).sort()) {
+      output[key] = canonicalizeInner(input[key]);
+    }
+    return output;
+  }
+  return String(value);
+}
+function canonicalizeValue(value) {
+  return canonicalizeInner(value);
+}
+function canonicalizeToString(value) {
+  return JSON.stringify(canonicalizeValue(value));
+}
+
+// src/core/confidence.ts
+var SIGNAL_WEIGHTS = {
+  ua: 0.5,
+  uaHints: 0.7,
+  locale: 0.5,
+  screen: 0.8,
+  hardware: 0.7,
+  storage: 0.4,
+  fonts: 0.9,
+  canvas: 1,
+  webgl: 1,
+  audio: 0.9,
+  mediaDevices: 0.6,
+  permissions: 0.4,
+  webrtc: 0.8,
+  frameInfo: 0.3,
+  networkInfo: 0.6,
+  paymentSupport: 0.2,
+  referrerInfo: 0.3,
+  navigationInfo: 0.4,
+  riskSignals: 0.7
+};
+function computeConfidence(signals, antiSpoof) {
+  let earned = 0;
+  let available = 0;
+  for (const [name, signal] of Object.entries(signals)) {
+    const weight = SIGNAL_WEIGHTS[name];
+    available += weight;
+    if (signal.status === "ok") {
+      earned += weight;
+      continue;
+    }
+    if (signal.status === "unsupported" || signal.status === "blocked") {
+      earned += weight * 0.35;
+      continue;
+    }
+    if (signal.status === "timeout") {
+      earned += weight * 0.15;
+    }
+  }
+  if (available === 0) {
+    return 0;
+  }
+  const base = earned / available;
+  const adjusted = base * (0.65 + antiSpoof.score * 0.35);
+  return Math.max(0, Math.min(1, Number(adjusted.toFixed(3))));
+}
+
+// src/core/events.ts
+var FingerprintEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Register an event listener.
+   *
+   * @typeParam K - Event name.
+   * @param event - The event to listen for.
+   * @param cb - Callback invoked on emit.
+   * @returns An unsubscribe function.
+   */
+  on(event, cb) {
+    const bucket = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    bucket.add(cb);
+    this.listeners.set(event, bucket);
+    return () => {
+      bucket.delete(cb);
+      if (bucket.size === 0) {
+        this.listeners.delete(event);
+      }
+    };
+  }
+  /**
+   * Emit an event to all registered listeners.
+   *
+   * @typeParam K - Event name.
+   * @param event - The event to emit.
+   * @param payload - Payload matching the event's type.
+   */
+  emit(event, payload) {
+    const bucket = this.listeners.get(event);
+    if (!bucket) {
+      return;
+    }
+    for (const listener of bucket) {
+      listener(payload);
+    }
+  }
+};
+
+// src/core/hash.ts
+var K = [
+  1116352408,
+  1899447441,
+  -1245643825,
+  -373957723,
+  961987163,
+  1508970993,
+  -1841331548,
+  -1424204075,
+  -670586216,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  -2132889090,
+  -1680079193,
+  -1046744716,
+  -459576895,
+  -272742522,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  -1740746414,
+  -1473132947,
+  -1341970488,
+  -1084653625,
+  -958395405,
+  -710438585,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  -2117940946,
+  -1838011259,
+  -1564481375,
+  -1474664885,
+  -1035236496,
+  -949202525,
+  -778901479,
+  -694614492,
+  -200395387,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  -2067236844,
+  -1933114872,
+  -1866530822,
+  -1538233109,
+  -1090935817,
+  -965641998
+];
+function rightRotate(value, amount) {
+  return value >>> amount | value << 32 - amount;
+}
+function utf8Encode(input) {
+  return new TextEncoder().encode(input);
+}
+function sha256Hex(input) {
+  const bytes = utf8Encode(input);
+  const bitLength = bytes.length * 8;
+  const withPaddingLength = bytes.length + 9 + 63 >> 6 << 6;
+  const padded = new Uint8Array(withPaddingLength);
+  padded.set(bytes);
+  padded[bytes.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(withPaddingLength - 4, bitLength, false);
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) {
+      w[i] = view.getUint32(offset + i * 4, false);
+    }
+    for (let i = 16; i < 64; i += 1) {
+      const s0 = rightRotate(w[i - 15], 7) ^ rightRotate(w[i - 15], 18) ^ w[i - 15] >>> 3;
+      const s1 = rightRotate(w[i - 2], 17) ^ rightRotate(w[i - 2], 19) ^ w[i - 2] >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let i = 0; i < 64; i += 1) {
+      const s1 = rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + K[i] + w[i] >>> 0;
+      const s0 = rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((part) => part.toString(16).padStart(8, "0")).join("");
+}
+
+// src/core/options.ts
+function withDefaultOptions(options) {
+  return {
+    debug: false,
+    extended: false,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    ...options
+  };
+}
+function resolveSignalSet(options, mode = "async") {
+  const resolved = withDefaultOptions(options);
+  const seed = resolved.extended ? [...CORE_SIGNALS, ...EXTENDED_SIGNALS] : [...CORE_SIGNALS];
+  const allowed = mode === "sync" ? seed.filter((signal) => SYNC_SIGNALS.includes(signal)) : seed;
+  const included = resolved.include ? allowed.filter((signal) => resolved.include?.includes(signal)) : allowed;
+  const excluded = new Set(resolved.exclude ?? []);
+  return included.filter((signal) => !excluded.has(signal));
+}
+
+// src/core/upload.ts
+async function uploadFingerprint(env, result, options) {
+  const fetchImpl = options.endpoint && env.fetch;
+  if (!fetchImpl) {
+    throw new Error("Fetch is not available in this runtime.");
+  }
+  return fetchImpl(options.endpoint, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...options.headers
+    },
+    body: JSON.stringify({
+      fingerprint: result,
+      ...options.bodyExtras
+    })
+  });
+}
+
+// src/version.ts
+var LIBRARY_VERSION = "0.1.0";
+var SCHEMA_VERSION = 1;
+
+// src/client.ts
+function toTimedOutResult(durationMs) {
+  return {
+    status: "timeout",
+    durationMs,
+    error: "Signal collection timed out."
+  };
+}
+async function runCollectorWithTimeout(collector, env, options, warn) {
+  const started = env.performance?.now?.() ?? Date.now();
+  if (options.abortSignal?.aborted) {
+    return {
+      status: "error",
+      durationMs: 0,
+      error: "Collection aborted before signal execution started."
+    };
+  }
+  let clearTimeoutHandle = () => {
+  };
+  const timeoutPromise = new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      resolve(toTimedOutResult((env.performance?.now?.() ?? Date.now()) - started));
+    }, options.timeoutMs);
+    clearTimeoutHandle = () => clearTimeout(timeout);
+    options.abortSignal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeoutHandle();
+        resolve({
+          status: "error",
+          durationMs: (env.performance?.now?.() ?? Date.now()) - started,
+          error: "Collection aborted."
+        });
+      },
+      { once: true }
+    );
+  });
+  const resultPromise = collector.collect({
+    env,
+    options,
+    warn
+  });
+  return Promise.race([resultPromise, timeoutPromise]).finally(() => {
+    clearTimeoutHandle();
+  });
+}
+function buildResult(signals, warnings, requestedSignals, elapsedMs) {
+  const componentHashes = {};
+  for (const [name, signal] of Object.entries(signals)) {
+    if (signal.value === void 0) {
+      continue;
+    }
+    componentHashes[name] = sha256Hex(canonicalizeToString(signal.value));
+  }
+  const thumbprint = sha256Hex(
+    canonicalizeToString(
+      Object.keys(componentHashes).sort().map((name) => [name, componentHashes[name]])
+    )
+  );
+  const antiSpoof = analyseSignals(signals);
+  const confidence = computeConfidence(signals, antiSpoof);
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    libraryVersion: LIBRARY_VERSION,
+    thumbprint,
+    confidence,
+    componentHashes,
+    signals,
+    antiSpoof,
+    warnings,
+    diagnostics: {
+      requestedSignals,
+      completedSignals: Object.keys(signals).sort(),
+      elapsedMs: Number(elapsedMs.toFixed(3))
+    }
+  };
+}
+async function createFingerprintClient(options) {
+  const baseOptions = withDefaultOptions(options);
+  const emitter = new FingerprintEmitter();
+  return {
+    on(event, cb) {
+      return emitter.on(event, cb);
+    },
+    async collect(overrides) {
+      const resolved = withDefaultOptions({ ...baseOptions, ...overrides });
+      const env = getBrowserEnv();
+      const signalNames = resolveSignalSet(resolved, "async");
+      const collected = {};
+      const warnings = [];
+      const started = env.performance?.now?.() ?? Date.now();
+      const warn = (message, signal) => {
+        warnings.push(message);
+        emitter.emit("warning", { signal, message });
+      };
+      let completed = 0;
+      await Promise.all(
+        signalNames.map(async (name) => {
+          const collector = collectorMap.get(name);
+          if (!collector) {
+            warn(`No collector registered for signal "${name}".`, name);
+            return;
+          }
+          const result = await runCollectorWithTimeout(collector, env, resolved, warn);
+          collected[name] = result;
+          completed += 1;
+          emitter.emit("progress", {
+            completed,
+            total: signalNames.length,
+            signal: name,
+            result
+          });
+        })
+      );
+      const output = buildResult(collected, warnings, signalNames, (env.performance?.now?.() ?? Date.now()) - started);
+      emitter.emit("complete", { result: output });
+      return output;
+    },
+    collectSync(overrides) {
+      const resolved = withDefaultOptions({ ...baseOptions, ...overrides });
+      const env = getBrowserEnv();
+      const signalNames = resolveSignalSet(resolved, "sync");
+      const collected = {};
+      const warnings = [];
+      const started = env.performance?.now?.() ?? Date.now();
+      const warn = (message, signal) => {
+        warnings.push(message);
+        emitter.emit("warning", { signal, message });
+      };
+      for (const name of signalNames) {
+        const collector = collectorMap.get(name);
+        if (!collector?.collectSync) {
+          warn(`Signal "${name}" is not available in synchronous mode.`, name);
+          continue;
+        }
+        collected[name] = collector.collectSync({
+          env,
+          options: resolved,
+          warn
+        });
+      }
+      return buildResult(collected, warnings, signalNames, (env.performance?.now?.() ?? Date.now()) - started);
+    },
+    upload(result, uploadOptions) {
+      return uploadFingerprint(getBrowserEnv(), result, uploadOptions);
+    }
+  };
+}
+export {
+  LIBRARY_VERSION,
+  SCHEMA_VERSION,
+  createFingerprintClient
+};