sitepong 0.2.1 → 0.2.2

package/dist/entries/web.mjs

@@ -684,6 +684,7 @@ var DEFAULT_BLOCK_SELECTORS = [
 var MAX_TEXT_LENGTH = 255;
 var AutocaptureModule = class {
   constructor(config, callback) {
+    this.listeners = [];
     this.clickHandler = null;
     this.submitHandler = null;
     this.active = false;
@@ -698,6 +699,27 @@ var AutocaptureModule = class {
     };
     this.callback = callback;
   }
+  /**
+   * Register a secondary listener that receives the same events as the
+   * primary callback (e.g. Watchtower tap capture reusing the single click
+   * listener + selector resolution). Returns an unsubscribe function.
+   */
+  addListener(cb) {
+    this.listeners.push(cb);
+    return () => {
+      const idx = this.listeners.indexOf(cb);
+      if (idx >= 0) this.listeners.splice(idx, 1);
+    };
+  }
+  emit(event) {
+    this.callback(event);
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
   start() {
     if (this.active || typeof document === "undefined" || typeof document.addEventListener !== "function") return;
     this.active = true;
@@ -730,7 +752,7 @@ var AutocaptureModule = class {
       properties.$event_type = "click";
       properties.$x = e.clientX;
       properties.$y = e.clientY;
-      this.callback({
+      this.emit({
         type: "click",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         properties
@@ -752,7 +774,7 @@ var AutocaptureModule = class {
       };
       const elemProps = this.getElementProperties(form);
       Object.assign(properties, elemProps);
-      this.callback({
+      this.emit({
         type: "form_submit",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         properties
@@ -969,6 +991,14 @@ var AnalyticsManager = class {
     );
     this.autocaptureModule.start();
   }
+  /**
+   * The live AutocaptureModule (if click/form autocapture is enabled) —
+   * Watchtower tap capture attaches to it so there is only ONE document-level
+   * click listener and one selector/element resolution path.
+   */
+  getAutocaptureModule() {
+    return this.autocaptureModule;
+  }
   track(eventName, properties) {
     if (!this.config.enabled) return;
     const event = this.createEvent("track", { name: eventName, properties });
@@ -1920,646 +1950,147 @@ var RemoteConfigManager = class {
     }
   }
 };
-var DEFAULT_ENDPOINT3 = "https://ingest.sitepong.com";
-var DEFAULT_FLUSH_INTERVAL2 = 1e4;
-var MAX_FLUSH_FAILURES2 = 3;
-var MAX_RESOURCES_PER_FLUSH = 200;
-var PAGE_TIMING_POLL_INTERVAL = 200;
-var PAGE_TIMING_TIMEOUT = 3e4;
-function getPaintBlocks(resources) {
-  const paintBlocks = [];
-  const elements = document.getElementsByTagName("*");
-  const styleURL = /url\(("[^"]*"|'[^']*'|[^)]*)\)/i;
-  for (let i = 0; i < elements.length; i++) {
-    const element = elements[i];
-    let src = "";
-    if (element.tagName === "IMG") {
-      src = element.currentSrc || element.src;
-    }
-    if (!src) {
-      const backgroundImage = getComputedStyle(element).getPropertyValue("background-image");
-      if (backgroundImage) {
-        const matches = styleURL.exec(backgroundImage);
-        if (matches !== null) {
-          src = matches[1];
-          if (src.startsWith('"') || src.startsWith("'")) {
-            src = src.substr(1, src.length - 2);
-          }
-        }
-      }
+
+// src/performance/tracing.ts
+function randomHex(byteLength) {
+  try {
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      const bytes = new Uint8Array(byteLength);
+      crypto.getRandomValues(bytes);
+      return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
     }
-    if (!src) continue;
-    const time = src.substr(0, 10) === "data:image" ? 0 : resources[src];
-    if (time === void 0) continue;
-    const rect = element.getBoundingClientRect();
-    const top = Math.max(rect.top, 0);
-    const left = Math.max(rect.left, 0);
-    const bottom = Math.min(
-      rect.bottom,
-      window.innerHeight || document.documentElement && document.documentElement.clientHeight || 0
-    );
-    const right = Math.min(
-      rect.right,
-      window.innerWidth || document.documentElement && document.documentElement.clientWidth || 0
-    );
-    if (bottom <= top || right <= left) continue;
-    const area = (bottom - top) * (right - left);
-    paintBlocks.push({ time, area });
+  } catch {
   }
-  return paintBlocks;
-}
-function calculateSpeedIndex(firstContentfulPaint, paintBlocks) {
-  let a = Math.max(
-    document.documentElement && document.documentElement.clientWidth || 0,
-    window.innerWidth || 0
-  ) * Math.max(
-    document.documentElement && document.documentElement.clientHeight || 0,
-    window.innerHeight || 0
-  ) / 10;
-  let s = a * firstContentfulPaint;
-  for (let i = 0; i < paintBlocks.length; i++) {
-    const { time, area } = paintBlocks[i];
-    a += area;
-    s += area * (time > firstContentfulPaint ? time : firstContentfulPaint);
+  let hex = "";
+  for (let i = 0; i < byteLength; i++) {
+    hex += Math.floor(Math.random() * 256).toString(16).padStart(2, "0");
   }
-  return a === 0 ? 0 : s / a;
+  return hex;
 }
-var PerformanceManager = class {
-  constructor(config) {
-    this.metrics = [];
-    this.flushTimer = null;
-    this.flushFailures = 0;
-    this.disabled = false;
-    this.vitals = {};
-    this.activeTransactions = /* @__PURE__ */ new Map();
-    // Resource timing state for Speed Index
-    this.resourceObserver = null;
-    this.resourceTimeMap = {};
-    this.resourceCount = 0;
-    // Page timing polling timers
-    this.pageLoadTimer = null;
-    this.pageRenderTimer = null;
-    this.config = {
-      endpoint: DEFAULT_ENDPOINT3,
-      enabled: true,
-      webVitals: true,
-      navigationTiming: true,
-      resourceTiming: true,
-      capturePageLoadTimings: true,
-      capturePageRenderTimings: true,
-      excludedResourceUrls: [],
-      flushInterval: DEFAULT_FLUSH_INTERVAL2,
-      sampleRate: 1,
-      debug: false,
-      ...config
-    };
-    this.sampled = Math.random() <= this.config.sampleRate;
+function generateTraceId() {
+  return randomHex(16);
+}
+function generateSpanId() {
+  return randomHex(8);
+}
+function createTraceContext() {
+  return {
+    traceId: generateTraceId(),
+    spanId: generateSpanId(),
+    parentSpanId: null,
+    sampled: true
+  };
+}
+function propagateTrace(context) {
+  const sampledFlag = context.sampled ? "01" : "00";
+  return {
+    traceparent: `00-${context.traceId}-${context.spanId}-${sampledFlag}`,
+    tracestate: `sitepong=${context.spanId}`
+  };
+}
+function extractTrace(headers) {
+  const traceparent = headers["traceparent"] || headers["Traceparent"];
+  if (!traceparent) {
+    return null;
   }
-  init() {
-    if (!this.config.enabled || !this.sampled) return;
-    if (typeof window === "undefined" || typeof window.addEventListener !== "function") return;
-    if (this.config.webVitals !== false) {
-      this.initWebVitals();
-    }
-    if (this.config.resourceTiming !== false) {
-      this.initResourceTiming();
-    }
-    if (this.config.capturePageLoadTimings !== false) {
-      this.initPageLoadTiming();
-    }
-    if (this.config.capturePageRenderTimings !== false) {
-      this.initPageRenderTiming();
-    }
-    this.startFlushTimer();
-    this.log("Performance monitoring initialized");
+  const parts = traceparent.split("-");
+  if (parts.length !== 4) {
+    return null;
   }
-  // ---- Web Vitals (via web-vitals library) ----
-  initWebVitals() {
-    onCLS((m) => {
-      this.vitals.cls = m.value;
-      this.reportVital("CLS", m.value, "score");
-    });
-    onINP((m) => {
-      this.vitals.inp = m.value;
-      this.reportVital("INP", m.value);
-    });
-    onLCP((m) => {
-      this.vitals.lcp = m.value;
-      this.reportVital("LCP", m.value);
-    });
-    onTTFB((m) => {
-      this.vitals.ttfb = m.value;
-      this.reportVital("TTFB", m.value);
-    });
-    onFCP((m) => {
-      this.vitals.fcp = m.value;
-      this.reportVital("FCP", m.value);
+  const [version, traceId, parentSpanId, flags] = parts;
+  if (version !== "00") {
+    return null;
+  }
+  if (traceId.length !== 32 || !/^[0-9a-f]{32}$/.test(traceId)) {
+    return null;
+  }
+  if (parentSpanId.length !== 16 || !/^[0-9a-f]{16}$/.test(parentSpanId)) {
+    return null;
+  }
+  if (flags.length !== 2 || !/^[0-9a-f]{2}$/.test(flags)) {
+    return null;
+  }
+  const sampled = (parseInt(flags, 16) & 1) === 1;
+  return {
+    traceId,
+    spanId: generateSpanId(),
+    parentSpanId,
+    sampled
+  };
+}
+var TracePropagator = class {
+  constructor(targets) {
+    this.originalFetch = null;
+    this.targets = targets;
+  }
+  shouldPropagate(url) {
+    return this.targets.some((pattern) => {
+      if (pattern.includes("*")) {
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+        const regex = new RegExp(`^${escaped}$`);
+        return regex.test(url);
+      }
+      return url.startsWith(pattern);
     });
   }
-  // ---- Resource Timing (adapted from OpenReplay timing.ts) ----
-  initResourceTiming() {
-    if (typeof PerformanceObserver === "undefined") return;
-    try {
-      this.resourceObserver = new PerformanceObserver((list) => {
-        for (const entry of list.getEntries()) {
-          this.processResourceEntry(entry);
-        }
-      });
-      this.resourceObserver.observe({ type: "resource", buffered: true });
-    } catch {
-      this.log("PerformanceObserver for resource timing not supported");
+  injectHeaders(url, headers, context) {
+    if (!this.shouldPropagate(url)) {
+      return headers;
     }
+    const traceHeaders = propagateTrace(context);
+    return {
+      ...headers,
+      ...traceHeaders
+    };
   }
-  isServiceURL(url) {
-    const endpoint = this.config.performanceEndpoint || this.config.endpoint;
-    return url.startsWith(endpoint);
-  }
-  processResourceEntry(entry) {
-    if (entry.duration < 0 || !entry.name.startsWith("http")) return;
-    if (this.isServiceURL(entry.name)) return;
-    if (this.resourceTimeMap !== null) {
-      this.resourceTimeMap[entry.name] = entry.startTime + entry.duration;
+  start() {
+    if (typeof window === "undefined" || !window.fetch) {
+      return;
     }
-    for (const excluded of this.config.excludedResourceUrls) {
-      if (entry.name.startsWith(excluded)) return;
+    if (this.originalFetch) {
+      return;
     }
-    if (this.resourceCount >= MAX_RESOURCES_PER_FLUSH) return;
-    this.resourceCount++;
-    let stalled = 0;
-    if (entry.connectEnd && entry.connectEnd > entry.domainLookupEnd) {
-      stalled = Math.max(0, entry.requestStart - entry.connectEnd);
-    } else {
-      stalled = Math.max(0, entry.requestStart - entry.domainLookupEnd);
-    }
-    const cached = entry.responseStatus && entry.responseStatus === 304 || entry.deliveryType && entry.deliveryType === "cache" || entry.transferSize === 0 && entry.decodedBodySize > 0;
-    const responseStatus = entry.responseStatus || 0;
-    const failed = responseStatus >= 400;
-    const breakdown = {
-      queueing: entry.requestStart - entry.fetchStart,
-      dnsLookup: entry.domainLookupEnd - entry.domainLookupStart,
-      initialConnection: entry.connectEnd - entry.connectStart,
-      ssl: entry.secureConnectionStart > 0 ? entry.connectEnd - entry.secureConnectionStart : 0,
-      ttfb: entry.responseStart - entry.requestStart,
-      contentDownload: entry.responseEnd - entry.responseStart,
-      total: entry.duration ?? entry.responseEnd - entry.startTime,
-      stalled,
-      cached,
-      failed,
-      responseStatus,
-      headerSize: entry.transferSize > entry.encodedBodySize ? entry.transferSize - entry.encodedBodySize : 0,
-      encodedBodySize: entry.encodedBodySize || 0,
-      decodedBodySize: failed ? -111 : entry.decodedBodySize || 0,
-      transferSize: entry.transferSize,
-      initiatorType: entry.initiatorType
-    };
-    const entryName = this.config.resourceNameSanitizer ? this.config.resourceNameSanitizer(entry.name) : entry.name;
-    this.addMetric({
-      type: "resource",
-      name: entryName,
-      value: entry.duration,
-      unit: "ms",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      url: typeof window !== "undefined" && window.location ? window.location.href : void 0,
-      data: breakdown
-    });
-  }
-  // ---- Page Load Timing (adapted from OpenReplay timing.ts) ----
-  initPageLoadTiming() {
-    if (typeof window === "undefined" || !window.performance) return;
-    let firstPaint = 0;
-    let firstContentfulPaint = 0;
-    let sent = false;
-    const startTime = performance.now();
-    this.pageLoadTimer = setInterval(() => {
-      if (sent) {
-        if (this.pageLoadTimer) clearInterval(this.pageLoadTimer);
-        return;
-      }
-      if (firstPaint === 0 || firstContentfulPaint === 0) {
-        for (const entry of performance.getEntriesByType("paint")) {
-          if (entry.name === "first-paint") firstPaint = entry.startTime;
-          if (entry.name === "first-contentful-paint") firstContentfulPaint = entry.startTime;
-        }
-      }
-      const nav = performance.getEntriesByType("navigation")[0];
-      const timedOut = performance.now() - startTime > PAGE_TIMING_TIMEOUT;
-      if (nav && nav.loadEventEnd > 0 || timedOut) {
-        sent = true;
-        if (this.pageLoadTimer) clearInterval(this.pageLoadTimer);
-        if (nav) {
-          const navigationStart = nav.startTime;
-          this.addMetric({
-            type: "navigation",
-            name: "page_load",
-            value: nav.loadEventEnd - navigationStart,
-            unit: "ms",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            url: window.location.href,
-            data: {
-              requestStart: nav.requestStart - navigationStart,
-              responseStart: nav.responseStart - navigationStart,
-              responseEnd: nav.responseEnd - navigationStart,
-              domContentLoadedEventStart: nav.domContentLoadedEventEnd - navigationStart,
-              domContentLoadedEventEnd: nav.domContentLoadedEventEnd - navigationStart,
-              loadEventStart: nav.loadEventStart - navigationStart,
-              loadEventEnd: nav.loadEventEnd - navigationStart,
-              firstPaint,
-              firstContentfulPaint,
-              dns: nav.domainLookupEnd - nav.domainLookupStart,
-              tcp: nav.connectEnd - nav.connectStart,
-              ttfb: nav.responseStart - nav.requestStart,
-              domComplete: nav.domComplete - navigationStart,
-              transferSize: nav.transferSize,
-              encodedBodySize: nav.encodedBodySize,
-              decodedBodySize: nav.decodedBodySize
+    this.originalFetch = window.fetch;
+    const self = this;
+    window.fetch = function(input, init2) {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+      if (self.shouldPropagate(url)) {
+        const context = createTraceContext();
+        const traceHeaders = propagateTrace(context);
+        const existingHeaders = {};
+        if (init2?.headers) {
+          if (init2.headers instanceof Headers) {
+            init2.headers.forEach((value, key) => {
+              existingHeaders[key] = value;
+            });
+          } else if (Array.isArray(init2.headers)) {
+            for (const [key, value] of init2.headers) {
+              existingHeaders[key] = value;
             }
-          });
-        }
-      }
-    }, PAGE_TIMING_POLL_INTERVAL);
-  }
-  // ---- Page Render Timing: Speed Index, Visually Complete, TTI (adapted from OpenReplay) ----
-  initPageRenderTiming() {
-    if (typeof window === "undefined" || !window.performance) return;
-    let firstContentfulPaint = 0;
-    let visuallyComplete = 0;
-    let interactiveWindowStartTime = 0;
-    let interactiveWindowTickTime = 0;
-    let paintBlocks = null;
-    let sent = false;
-    const startTime = performance.now();
-    this.pageRenderTimer = setInterval(() => {
-      if (sent) {
-        if (this.pageRenderTimer) clearInterval(this.pageRenderTimer);
-        return;
-      }
-      const time = performance.now();
-      if (firstContentfulPaint === 0) {
-        for (const entry of performance.getEntriesByType("paint")) {
-          if (entry.name === "first-contentful-paint") {
-            firstContentfulPaint = entry.startTime;
+          } else {
+            Object.assign(existingHeaders, init2.headers);
           }
         }
+        const mergedHeaders = {
+          ...existingHeaders,
+          ...traceHeaders
+        };
+        const patchedInit = {
+          ...init2,
+          headers: mergedHeaders
+        };
+        return self.originalFetch.call(window, input, patchedInit);
       }
-      if (this.resourceTimeMap !== null) {
-        const times = Object.values(this.resourceTimeMap);
-        if (times.length > 0) {
-          visuallyComplete = Math.max(...times);
-        }
-        if (time - visuallyComplete > 1e3) {
-          paintBlocks = getPaintBlocks(this.resourceTimeMap);
-          this.resourceTimeMap = null;
-        }
-      }
-      if (interactiveWindowTickTime !== null) {
-        if (time - interactiveWindowTickTime > 50) {
-          interactiveWindowStartTime = time;
-        }
-        interactiveWindowTickTime = time - interactiveWindowStartTime > 5e3 ? null : time;
-      }
-      const timedOut = time - startTime > PAGE_TIMING_TIMEOUT;
-      if (paintBlocks !== null && interactiveWindowTickTime === null || timedOut) {
-        sent = true;
-        if (this.pageRenderTimer) clearInterval(this.pageRenderTimer);
-        this.resourceTimeMap = null;
-        const speedIndex = paintBlocks === null ? 0 : calculateSpeedIndex(firstContentfulPaint || 0, paintBlocks);
-        const nav = performance.getEntriesByType("navigation")[0];
-        const domContentLoadedEnd = nav ? nav.domContentLoadedEventEnd - nav.startTime : 0;
-        const timeToInteractive = interactiveWindowTickTime === null ? Math.max(interactiveWindowStartTime, firstContentfulPaint, domContentLoadedEnd) : 0;
-        const url = window.location.href;
-        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-        if (speedIndex > 0) {
-          this.addMetric({
-            type: "page_render",
-            name: "speed_index",
-            value: Math.round(speedIndex),
-            unit: "ms",
-            timestamp,
-            url
-          });
-        }
-        if (visuallyComplete > 0) {
-          this.addMetric({
-            type: "page_render",
-            name: "visually_complete",
-            value: Math.round(visuallyComplete),
-            unit: "ms",
-            timestamp,
-            url
-          });
-        }
-        if (timeToInteractive > 0) {
-          this.addMetric({
-            type: "page_render",
-            name: "tti",
-            value: Math.round(timeToInteractive),
-            unit: "ms",
-            timestamp,
-            url
-          });
-        }
-      }
-    }, PAGE_TIMING_POLL_INTERVAL);
-  }
-  // ---- Transactions / Spans (unchanged) ----
-  startTransaction(name, data) {
-    const id = `txn_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
-    const transaction = {
-      id,
-      name,
-      startTime: performance.now(),
-      status: "running",
-      spans: [],
-      data
+      return self.originalFetch.call(window, input, init2);
     };
-    this.activeTransactions.set(id, transaction);
-    this.log("Transaction started:", name, id);
-    return id;
   }
-  endTransaction(id, status = "ok") {
-    const transaction = this.activeTransactions.get(id);
-    if (!transaction) {
-      this.log("Transaction not found:", id);
+  stop() {
+    if (typeof window === "undefined") {
       return;
     }
-    transaction.endTime = performance.now();
-    transaction.duration = transaction.endTime - transaction.startTime;
-    transaction.status = status;
-    for (const span of transaction.spans) {
-      if (span.status === "running") {
-        span.endTime = transaction.endTime;
-        span.duration = span.endTime - span.startTime;
-        span.status = status;
-      }
-    }
-    this.activeTransactions.delete(id);
-    this.addMetric({
-      type: "transaction",
-      name: transaction.name,
-      value: transaction.duration,
-      unit: "ms",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      url: typeof window !== "undefined" && window.location ? window.location.href : void 0,
-      transaction
-    });
-    this.log("Transaction ended:", transaction.name, `${transaction.duration.toFixed(1)}ms`);
-  }
-  startSpan(transactionId, name, data) {
-    const transaction = this.activeTransactions.get(transactionId);
-    if (!transaction) {
-      this.log("Transaction not found for span:", transactionId);
-      return "";
-    }
-    const span = {
-      id: `span_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`,
-      name,
-      startTime: performance.now(),
-      status: "running",
-      data
-    };
-    transaction.spans.push(span);
-    return span.id;
-  }
-  endSpan(transactionId, spanId, status = "ok") {
-    const transaction = this.activeTransactions.get(transactionId);
-    if (!transaction) return;
-    const span = transaction.spans.find((s) => s.id === spanId);
-    if (!span) return;
-    span.endTime = performance.now();
-    span.duration = span.endTime - span.startTime;
-    span.status = status;
-  }
-  // ---- Public API ----
-  getVitals() {
-    return { ...this.vitals };
-  }
-  destroy() {
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-      this.flushTimer = null;
-    }
-    if (this.pageLoadTimer) {
-      clearInterval(this.pageLoadTimer);
-      this.pageLoadTimer = null;
-    }
-    if (this.pageRenderTimer) {
-      clearInterval(this.pageRenderTimer);
-      this.pageRenderTimer = null;
-    }
-    if (this.resourceObserver) {
-      this.resourceObserver.disconnect();
-      this.resourceObserver = null;
-    }
-    this.flush();
-  }
-  // ---- Internal ----
-  reportVital(name, value, unit = "ms") {
-    this.addMetric({
-      type: "web_vital",
-      name,
-      value,
-      unit,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      url: typeof window !== "undefined" && window.location ? window.location.href : void 0
-    });
-  }
-  addMetric(metric) {
-    this.metrics.push(metric);
-  }
-  startFlushTimer() {
-    this.flushTimer = setInterval(() => {
-      this.flush();
-    }, this.config.flushInterval);
-    if (typeof document !== "undefined") {
-      document.addEventListener("visibilitychange", () => {
-        if (document.visibilityState === "hidden") {
-          this.flush();
-        }
-      });
-    }
-  }
-  async flush() {
-    if (this.metrics.length === 0) return;
-    if (this.disabled) {
-      this.metrics = [];
-      return;
-    }
-    const metrics = [...this.metrics];
-    this.metrics = [];
-    this.resourceCount = 0;
-    const endpoint = this.config.performanceEndpoint || `${this.config.endpoint}/api/performance`;
-    try {
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-Key": this.config.apiKey
-        },
-        body: JSON.stringify({ metrics })
-      });
-      if (!response.ok) throw new Error(`HTTP ${response.status}`);
-      this.flushFailures = 0;
-      this.log(`Flushed ${metrics.length} performance metrics`);
-    } catch (err) {
-      this.flushFailures++;
-      if (this.flushFailures >= MAX_FLUSH_FAILURES2) {
-        this.disabled = true;
-        console.warn(
-          `[SitePong Performance] Disabled after ${MAX_FLUSH_FAILURES2} consecutive failures. Check that ${endpoint} is accessible and has proper CORS headers.`
-        );
-        return;
-      }
-      this.metrics.unshift(...metrics);
-      this.log(`Failed to flush metrics (attempt ${this.flushFailures}/${MAX_FLUSH_FAILURES2}):`, err);
-    }
-  }
-  log(...args) {
-    if (this.config.debug) {
-      console.log("[SitePong Performance]", ...args);
-    }
-  }
-};
-
-// src/performance/tracing.ts
-function randomHex(byteLength) {
-  try {
-    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-      const bytes = new Uint8Array(byteLength);
-      crypto.getRandomValues(bytes);
-      return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-    }
-  } catch {
-  }
-  let hex = "";
-  for (let i = 0; i < byteLength; i++) {
-    hex += Math.floor(Math.random() * 256).toString(16).padStart(2, "0");
-  }
-  return hex;
-}
-function generateTraceId() {
-  return randomHex(16);
-}
-function generateSpanId() {
-  return randomHex(8);
-}
-function createTraceContext() {
-  return {
-    traceId: generateTraceId(),
-    spanId: generateSpanId(),
-    parentSpanId: null,
-    sampled: true
-  };
-}
-function propagateTrace(context) {
-  const sampledFlag = context.sampled ? "01" : "00";
-  return {
-    traceparent: `00-${context.traceId}-${context.spanId}-${sampledFlag}`,
-    tracestate: `sitepong=${context.spanId}`
-  };
-}
-function extractTrace(headers) {
-  const traceparent = headers["traceparent"] || headers["Traceparent"];
-  if (!traceparent) {
-    return null;
-  }
-  const parts = traceparent.split("-");
-  if (parts.length !== 4) {
-    return null;
-  }
-  const [version, traceId, parentSpanId, flags] = parts;
-  if (version !== "00") {
-    return null;
-  }
-  if (traceId.length !== 32 || !/^[0-9a-f]{32}$/.test(traceId)) {
-    return null;
-  }
-  if (parentSpanId.length !== 16 || !/^[0-9a-f]{16}$/.test(parentSpanId)) {
-    return null;
-  }
-  if (flags.length !== 2 || !/^[0-9a-f]{2}$/.test(flags)) {
-    return null;
-  }
-  const sampled = (parseInt(flags, 16) & 1) === 1;
-  return {
-    traceId,
-    spanId: generateSpanId(),
-    parentSpanId,
-    sampled
-  };
-}
-var TracePropagator = class {
-  constructor(targets) {
-    this.originalFetch = null;
-    this.targets = targets;
-  }
-  shouldPropagate(url) {
-    return this.targets.some((pattern) => {
-      if (pattern.includes("*")) {
-        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-        const regex = new RegExp(`^${escaped}$`);
-        return regex.test(url);
-      }
-      return url.startsWith(pattern);
-    });
-  }
-  injectHeaders(url, headers, context) {
-    if (!this.shouldPropagate(url)) {
-      return headers;
-    }
-    const traceHeaders = propagateTrace(context);
-    return {
-      ...headers,
-      ...traceHeaders
-    };
-  }
-  start() {
-    if (typeof window === "undefined" || !window.fetch) {
-      return;
-    }
-    if (this.originalFetch) {
-      return;
-    }
-    this.originalFetch = window.fetch;
-    const self = this;
-    window.fetch = function(input, init2) {
-      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-      if (self.shouldPropagate(url)) {
-        const context = createTraceContext();
-        const traceHeaders = propagateTrace(context);
-        const existingHeaders = {};
-        if (init2?.headers) {
-          if (init2.headers instanceof Headers) {
-            init2.headers.forEach((value, key) => {
-              existingHeaders[key] = value;
-            });
-          } else if (Array.isArray(init2.headers)) {
-            for (const [key, value] of init2.headers) {
-              existingHeaders[key] = value;
-            }
-          } else {
-            Object.assign(existingHeaders, init2.headers);
-          }
-        }
-        const mergedHeaders = {
-          ...existingHeaders,
-          ...traceHeaders
-        };
-        const patchedInit = {
-          ...init2,
-          headers: mergedHeaders
-        };
-        return self.originalFetch.call(window, input, patchedInit);
-      }
-      return self.originalFetch.call(window, input, init2);
-    };
-  }
-  stop() {
-    if (typeof window === "undefined") {
-      return;
-    }
-    if (this.originalFetch) {
-      window.fetch = this.originalFetch;
-      this.originalFetch = null;
+    if (this.originalFetch) {
+      window.fetch = this.originalFetch;
+      this.originalFetch = null;
     }
   }
 };
@@ -2957,10 +2488,10 @@ var webManagerFactories = {};
 function registerWebManagerFactories(factories) {
   webManagerFactories = { ...webManagerFactories, ...factories };
 }
-var DEFAULT_ENDPOINT4 = "https://ingest.sitepong.com";
+var DEFAULT_ENDPOINT3 = "https://ingest.sitepong.com";
 var DEFAULT_BATCH_SIZE2 = 10;
-var DEFAULT_FLUSH_INTERVAL3 = 5e3;
-var MAX_FLUSH_FAILURES3 = 3;
+var DEFAULT_FLUSH_INTERVAL2 = 5e3;
+var MAX_FLUSH_FAILURES2 = 3;
 var SitePongClient = class {
   constructor() {
     this.errorQueue = [];
@@ -2979,16 +2510,18 @@ var SitePongClient = class {
     this.databaseTracker = null;
     this.profiler = null;
     this.remoteConfigManager = null;
+    this.watchtowerCapture = null;
+    this.watchtowerOptions = void 0;
     this.envUnsubs = [];
     this.identifyHooks = [];
     this.config = {
       apiKey: "",
-      endpoint: DEFAULT_ENDPOINT4,
+      endpoint: DEFAULT_ENDPOINT3,
       environment: "production",
       release: "",
       autoCapture: true,
       maxBatchSize: DEFAULT_BATCH_SIZE2,
-      flushInterval: DEFAULT_FLUSH_INTERVAL3,
+      flushInterval: DEFAULT_FLUSH_INTERVAL2,
       debug: false
     };
   }
@@ -3010,7 +2543,7 @@ var SitePongClient = class {
     if (config.enableFlags) {
       this.flagManager = new FlagManager({
         apiKey: config.apiKey,
-        endpoint: config.flagsEndpoint || config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.flagsEndpoint || config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug
       });
       this.flagManager.init().catch((err) => {
@@ -3023,7 +2556,7 @@ var SitePongClient = class {
       }
       this.analyticsManager = new AnalyticsManager({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         enabled: true,
         autocapturePageviews: config.analytics.autocapturePageviews,
         autocaptureClicks: config.analytics.autocaptureClicks,
@@ -3039,7 +2572,7 @@ var SitePongClient = class {
     if (config.fingerprint?.enabled && webManagerFactories.createFingerprint) {
       this.fingerprintManager = webManagerFactories.createFingerprint({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         enabled: true,
         extendedSignals: config.fingerprint.extendedSignals,
         visitorEndpoint: config.fingerprint.visitorEndpoint,
@@ -3054,7 +2587,7 @@ var SitePongClient = class {
       }
       this.performanceManager = webManagerFactories.createPerformance({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         enabled: true,
         webVitals: config.performance.webVitals,
         navigationTiming: config.performance.navigationTiming,
@@ -3078,7 +2611,7 @@ var SitePongClient = class {
       }
       this.replayManager = webManagerFactories.createReplay({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         enabled: true,
         maskInputs: config.replay.maskInputs,
         blockSelector: config.replay.blockSelector,
@@ -3098,17 +2631,23 @@ var SitePongClient = class {
     } else if (config.replay?.enabled) {
       this.log("Replay requested but not available on this platform (web only).");
     }
+    this.watchtowerOptions = config.watchtower;
+    if (config.watchtower?.enabled && webManagerFactories.createWatchtowerCapture) {
+      this.startWatchtowerCapture();
+    } else if (config.watchtower?.enabled) {
+      this.log("Watchtower capture requested but not available on this platform (web only).");
+    }
     if (config.crons?.enabled) {
       this.cronManager = new CronMonitorManager({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug
       });
     }
     if (config.database?.enabled) {
       this.databaseTracker = new DatabaseTracker({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug,
         slowQueryThreshold: config.database.slowQueryThreshold,
         redactParams: config.database.redactParams
@@ -3117,7 +2656,7 @@ var SitePongClient = class {
     if (config.metrics?.enabled) {
       this.metricsManager = new MetricsManager({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug,
         flushInterval: config.metrics.flushInterval,
         maxBatchSize: config.metrics.maxBatchSize
@@ -3126,7 +2665,7 @@ var SitePongClient = class {
     if (config.profiling?.enabled) {
       this.profiler = new Profiler({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug,
         sampleRate: config.profiling.sampleRate,
         maxDuration: config.profiling.maxDuration,
@@ -3137,7 +2676,7 @@ var SitePongClient = class {
       const storage = config._storageAdapter || getStorageAdapter();
       this.remoteConfigManager = new RemoteConfigManager({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         storage,
         debug: config.debug
       });
@@ -3171,7 +2710,7 @@ var SitePongClient = class {
     if (config.enableFlags) {
       this.flagManager = new FlagManager({
         apiKey: config.apiKey,
-        endpoint: config.flagsEndpoint || config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.flagsEndpoint || config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug
       });
       this.flagManager.init().catch((err) => {
@@ -3184,7 +2723,7 @@ var SitePongClient = class {
       }
       this.analyticsManager = new AnalyticsManager({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         enabled: true,
         maxBatchSize: config.analytics.maxBatchSize,
         flushInterval: config.analytics.flushInterval,
@@ -3196,14 +2735,14 @@ var SitePongClient = class {
     if (config.crons?.enabled) {
       this.cronManager = new CronMonitorManager({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug
       });
     }
     if (config.metrics?.enabled) {
       this.metricsManager = new MetricsManager({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug,
         flushInterval: config.metrics.flushInterval,
         maxBatchSize: config.metrics.maxBatchSize
@@ -3212,7 +2751,7 @@ var SitePongClient = class {
     if (config.database?.enabled) {
       this.databaseTracker = new DatabaseTracker({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug,
         slowQueryThreshold: config.database.slowQueryThreshold,
         redactParams: config.database.redactParams
@@ -3221,7 +2760,7 @@ var SitePongClient = class {
     if (config.profiling?.enabled) {
       this.profiler = new Profiler({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         debug: config.debug,
         sampleRate: config.profiling.sampleRate,
         maxDuration: config.profiling.maxDuration,
@@ -3232,7 +2771,7 @@ var SitePongClient = class {
       const storage = config._storageAdapter || getStorageAdapter();
       this.remoteConfigManager = new RemoteConfigManager({
         apiKey: config.apiKey,
-        endpoint: config.endpoint || DEFAULT_ENDPOINT4,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT3,
         storage,
         debug: config.debug
       });
@@ -3337,6 +2876,7 @@ var SitePongClient = class {
         this.log("identify hook failed:", err);
       }
     }
+    this.watchtowerCapture?.setDistinctId(userId);
     if (!this.analyticsManager) {
       this.log("Analytics not enabled. Set analytics.enabled: true in init()");
       return;
@@ -3404,13 +2944,56 @@ var SitePongClient = class {
   getReplaySessionId() {
     return this.replayManager?.getSessionId() ?? null;
   }
-  // --- Performance (Tier 7) ---
-  startTransaction(name, data) {
-    if (!this.performanceManager) {
-      this.log("Performance not enabled. Set performance.enabled: true in init()");
-      return "";
-    }
-    return this.performanceManager.startTransaction(name, data);
+  // --- Watchtower tap capture (web) ---
+  /**
+   * Start Watchtower web tap capture. Options merge over `watchtower` from
+   * init(); `projectId` is required (either here or in init config). Reuses
+   * the analytics AutocaptureModule's click listener when autocapture is on.
+   */
+  startWatchtowerCapture(options) {
+    if (!webManagerFactories.createWatchtowerCapture) {
+      this.log("Watchtower capture not available on this platform (web only).");
+      return false;
+    }
+    if (!this.initialized || !this.config.apiKey) {
+      this.log("Watchtower capture requires init() to be called first.");
+      return false;
+    }
+    const opts = { ...this.watchtowerOptions, ...options };
+    if (!opts.projectId) {
+      this.log("Watchtower capture requires watchtower.projectId.");
+      return false;
+    }
+    if (this.watchtowerCapture) {
+      this.watchtowerCapture.stop();
+      this.watchtowerCapture = null;
+    }
+    this.watchtowerCapture = webManagerFactories.createWatchtowerCapture({
+      apiKey: this.config.apiKey,
+      projectId: opts.projectId,
+      endpoint: opts.endpoint || this.config.endpoint || DEFAULT_ENDPOINT3,
+      appVersion: this.config.release || void 0,
+      maxBatchSize: opts.maxBatchSize,
+      flushInterval: opts.flushInterval,
+      blockSelector: opts.blockSelector,
+      maskSelector: opts.maskSelector,
+      debug: this.config.debug
+    });
+    this.watchtowerCapture.start(this.analyticsManager?.getAutocaptureModule() ?? null);
+    return true;
+  }
+  stopWatchtowerCapture() {
+    if (!this.watchtowerCapture) return;
+    this.watchtowerCapture.stop();
+    this.watchtowerCapture = null;
+  }
+  // --- Performance (Tier 7) ---
+  startTransaction(name, data) {
+    if (!this.performanceManager) {
+      this.log("Performance not enabled. Set performance.enabled: true in init()");
+      return "";
+    }
+    return this.performanceManager.startTransaction(name, data);
   }
   endTransaction(id, status = "ok") {
     if (!this.performanceManager) return;
@@ -3555,6 +3138,7 @@ var SitePongClient = class {
     if (this.replayManager) {
       this.replayManager.setUser(null);
     }
+    this.watchtowerCapture?.setDistinctId(null);
   }
   addBreadcrumb(breadcrumb) {
     this.log("Breadcrumb added:", breadcrumb);
@@ -3624,15 +3208,15 @@ var SitePongClient = class {
       this.log(`Flushed ${errors.length} errors`);
     } catch (err) {
       this.flushFailures++;
-      if (this.flushFailures >= MAX_FLUSH_FAILURES3) {
+      if (this.flushFailures >= MAX_FLUSH_FAILURES2) {
         this.disabled = true;
         console.warn(
-          `[SitePong] SDK disabled after ${MAX_FLUSH_FAILURES3} consecutive failures. Events will no longer be sent. This may be due to CORS issues or network problems. Check that ${this.config.endpoint} is accessible and has proper CORS headers.`
+          `[SitePong] SDK disabled after ${MAX_FLUSH_FAILURES2} consecutive failures. Events will no longer be sent. This may be due to CORS issues or network problems. Check that ${this.config.endpoint} is accessible and has proper CORS headers.`
         );
         return;
       }
       this.errorQueue.unshift(...errors);
-      this.log(`Failed to flush errors (attempt ${this.flushFailures}/${MAX_FLUSH_FAILURES3}):`, err);
+      this.log(`Failed to flush errors (attempt ${this.flushFailures}/${MAX_FLUSH_FAILURES2}):`, err);
     }
   }
   formatError(error, additionalContext) {
@@ -3779,6 +3363,8 @@ var getDeviceSignals = sitepong.getDeviceSignals.bind(sitepong);
 var getFraudCheck = sitepong.getFraudCheck.bind(sitepong);
 var startReplay = sitepong.startReplay.bind(sitepong);
 var stopReplay = sitepong.stopReplay.bind(sitepong);
+var startWatchtowerCapture = sitepong.startWatchtowerCapture.bind(sitepong);
+var stopWatchtowerCapture = sitepong.stopWatchtowerCapture.bind(sitepong);
 var isReplayRecording = sitepong.isReplayRecording.bind(sitepong);
 var getReplaySessionId = sitepong.getReplaySessionId.bind(sitepong);
 var startTransaction = sitepong.startTransaction.bind(sitepong);
@@ -4495,10 +4081,10 @@ var ConsoleRecorder = class {
 };
 
 // src/replay/manager.ts
-var DEFAULT_ENDPOINT5 = "https://ingest.sitepong.com";
+var DEFAULT_ENDPOINT4 = "https://ingest.sitepong.com";
 var DEFAULT_BUFFER_DURATION = 2e4;
 var DEFAULT_MAX_SESSION_DURATION = 60 * 60 * 1e3;
-var MAX_FLUSH_FAILURES4 = 3;
+var MAX_FLUSH_FAILURES3 = 3;
 var TRIM_INTERVAL = 5e3;
 var ReplayManager = class {
   constructor(config) {
@@ -4525,7 +4111,7 @@ var ReplayManager = class {
     /** Most recent full snapshot, kept so we can prepend it to error replays */
     this.latestSnapshot = null;
     this.config = {
-      endpoint: DEFAULT_ENDPOINT5,
+      endpoint: DEFAULT_ENDPOINT4,
       enabled: true,
       maskInputs: true,
       maxSessionDuration: DEFAULT_MAX_SESSION_DURATION,
@@ -4661,14 +4247,14 @@ var ReplayManager = class {
       this.log(`Flushed ${eventsToSend.length} replay events (error-triggered)`);
     } catch (err) {
       this.flushFailures++;
-      if (this.flushFailures >= MAX_FLUSH_FAILURES4) {
+      if (this.flushFailures >= MAX_FLUSH_FAILURES3) {
         this.disabled = true;
         console.warn(
-          `[SitePong Replay] Disabled after ${MAX_FLUSH_FAILURES4} consecutive failures. Check that ${endpoint} is accessible and has proper CORS headers.`
+          `[SitePong Replay] Disabled after ${MAX_FLUSH_FAILURES3} consecutive failures. Check that ${endpoint} is accessible and has proper CORS headers.`
         );
         return;
       }
-      this.log(`Failed to flush replay events (attempt ${this.flushFailures}/${MAX_FLUSH_FAILURES4}):`, err);
+      this.log(`Failed to flush replay events (attempt ${this.flushFailures}/${MAX_FLUSH_FAILURES3}):`, err);
     }
   }
   /**
@@ -5963,544 +5549,1759 @@ var BehaviorAnalyzer = class {
     const score = this.calculateHumanScore(mouse, keyboard, scroll, clicks);
     return { mouse, keyboard, scroll, clicks, score };
   }
-  reset() {
-    this.mousePoints = [];
-    this.keyDownTimes.clear();
-    this.keyIntervals = [];
-    this.keyHoldTimes = [];
-    this.lastKeyTime = 0;
-    this.scrollEvents = [];
-    this.clickTimes = [];
+  reset() {
+    this.mousePoints = [];
+    this.keyDownTimes.clear();
+    this.keyIntervals = [];
+    this.keyHoldTimes = [];
+    this.lastKeyTime = 0;
+    this.scrollEvents = [];
+    this.clickTimes = [];
+  }
+  analyzeMouseMovement() {
+    if (this.mousePoints.length < 3) {
+      return {
+        totalMovements: this.mousePoints.length,
+        averageSpeed: 0,
+        maxSpeed: 0,
+        averageAcceleration: 0,
+        straightLineRatio: 0,
+        jitter: 0,
+        hasMovement: false
+      };
+    }
+    const speeds = [];
+    const accelerations = [];
+    let straightSegments = 0;
+    let totalSegments = 0;
+    let jitterSum = 0;
+    for (let i = 1; i < this.mousePoints.length; i++) {
+      const prev = this.mousePoints[i - 1];
+      const curr = this.mousePoints[i];
+      const dt = curr.t - prev.t || 1;
+      const dx = curr.x - prev.x;
+      const dy = curr.y - prev.y;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      const speed = distance / dt;
+      speeds.push(speed);
+      if (distance < 3 && distance > 0) {
+        jitterSum++;
+      }
+      if (i >= 2) {
+        const pp = this.mousePoints[i - 2];
+        const expectedX = pp.x + (curr.x - pp.x) * ((prev.t - pp.t) / (curr.t - pp.t));
+        const expectedY = pp.y + (curr.y - pp.y) * ((prev.t - pp.t) / (curr.t - pp.t));
+        const deviation = Math.sqrt((prev.x - expectedX) ** 2 + (prev.y - expectedY) ** 2);
+        totalSegments++;
+        if (deviation < 2) straightSegments++;
+      }
+      if (i >= 2) {
+        const prevSpeed = speeds[speeds.length - 2] || 0;
+        accelerations.push(Math.abs(speed - prevSpeed) / dt);
+      }
+    }
+    const avgSpeed = speeds.reduce((a, b) => a + b, 0) / speeds.length;
+    const maxSpeed = Math.max(...speeds);
+    const avgAccel = accelerations.length > 0 ? accelerations.reduce((a, b) => a + b, 0) / accelerations.length : 0;
+    return {
+      totalMovements: this.mousePoints.length,
+      averageSpeed: Math.round(avgSpeed * 1e3) / 1e3,
+      maxSpeed: Math.round(maxSpeed * 1e3) / 1e3,
+      averageAcceleration: Math.round(avgAccel * 1e3) / 1e3,
+      straightLineRatio: totalSegments > 0 ? straightSegments / totalSegments : 0,
+      jitter: this.mousePoints.length > 0 ? jitterSum / this.mousePoints.length : 0,
+      hasMovement: true
+    };
+  }
+  analyzeKeyboard() {
+    if (this.keyIntervals.length < 2) {
+      return {
+        totalKeystrokes: this.keyIntervals.length,
+        averageInterval: 0,
+        intervalVariance: 0,
+        holdTimeAverage: 0,
+        holdTimeVariance: 0,
+        hasKeystrokes: false
+      };
+    }
+    const avgInterval = this.keyIntervals.reduce((a, b) => a + b, 0) / this.keyIntervals.length;
+    const intervalVar = this.variance(this.keyIntervals);
+    const avgHold = this.keyHoldTimes.length > 0 ? this.keyHoldTimes.reduce((a, b) => a + b, 0) / this.keyHoldTimes.length : 0;
+    const holdVar = this.keyHoldTimes.length > 0 ? this.variance(this.keyHoldTimes) : 0;
+    return {
+      totalKeystrokes: this.keyIntervals.length + 1,
+      averageInterval: Math.round(avgInterval),
+      intervalVariance: Math.round(intervalVar),
+      holdTimeAverage: Math.round(avgHold),
+      holdTimeVariance: Math.round(holdVar),
+      hasKeystrokes: true
+    };
+  }
+  analyzeScroll() {
+    if (this.scrollEvents.length < 2) {
+      return { totalScrolls: this.scrollEvents.length, averageSpeed: 0, smoothness: 0, hasScroll: false };
+    }
+    const speeds = [];
+    for (let i = 1; i < this.scrollEvents.length; i++) {
+      const dt = this.scrollEvents[i].t - this.scrollEvents[i - 1].t || 1;
+      const dy = Math.abs(this.scrollEvents[i].deltaY - this.scrollEvents[i - 1].deltaY);
+      speeds.push(dy / dt);
+    }
+    const avgSpeed = speeds.reduce((a, b) => a + b, 0) / speeds.length;
+    const speedVar = this.variance(speeds);
+    const smoothness = avgSpeed > 0 ? Math.min(1, avgSpeed / (speedVar + avgSpeed)) : 0;
+    return {
+      totalScrolls: this.scrollEvents.length,
+      averageSpeed: Math.round(avgSpeed * 100) / 100,
+      smoothness: Math.round(smoothness * 100) / 100,
+      hasScroll: true
+    };
+  }
+  analyzeClicks() {
+    if (this.clickTimes.length < 2) {
+      return {
+        totalClicks: this.clickTimes.length,
+        averageInterval: 0,
+        intervalVariance: 0,
+        doubleClickCount: 0,
+        hasClicks: this.clickTimes.length > 0
+      };
+    }
+    const intervals = [];
+    let doubleClicks = 0;
+    for (let i = 1; i < this.clickTimes.length; i++) {
+      const interval = this.clickTimes[i] - this.clickTimes[i - 1];
+      intervals.push(interval);
+      if (interval < 500) doubleClicks++;
+    }
+    const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+    const intervalVar = this.variance(intervals);
+    return {
+      totalClicks: this.clickTimes.length,
+      averageInterval: Math.round(avgInterval),
+      intervalVariance: Math.round(intervalVar),
+      doubleClickCount: doubleClicks,
+      hasClicks: true
+    };
+  }
+  calculateHumanScore(mouse, keyboard, scroll, clicks) {
+    let score = 0.5;
+    let factors = 0;
+    if (mouse.hasMovement) {
+      factors++;
+      let mouseScore = 0.5;
+      if (mouse.jitter > 0.05) mouseScore += 0.15;
+      if (mouse.straightLineRatio < 0.5) mouseScore += 0.15;
+      else if (mouse.straightLineRatio > 0.9) mouseScore -= 0.2;
+      if (mouse.averageSpeed > 0 && mouse.maxSpeed / mouse.averageSpeed > 3) {
+        mouseScore += 0.1;
+      }
+      if (mouse.averageAcceleration > 0) mouseScore += 0.1;
+      score += Math.max(0, Math.min(1, mouseScore)) - 0.5;
+    }
+    if (keyboard.hasKeystrokes) {
+      factors++;
+      let keyScore = 0.5;
+      if (keyboard.intervalVariance > 1e3) keyScore += 0.2;
+      else if (keyboard.intervalVariance < 100) keyScore -= 0.2;
+      const cv = keyboard.averageInterval > 0 ? Math.sqrt(keyboard.intervalVariance) / keyboard.averageInterval : 0;
+      if (cv > 0.3) keyScore += 0.15;
+      if (keyboard.holdTimeVariance > 500) keyScore += 0.1;
+      score += Math.max(0, Math.min(1, keyScore)) - 0.5;
+    }
+    if (scroll.hasScroll) {
+      factors++;
+      let scrollScore = 0.5;
+      if (scroll.smoothness > 0.3 && scroll.smoothness < 0.9) {
+        scrollScore += 0.2;
+      }
+      score += Math.max(0, Math.min(1, scrollScore)) - 0.5;
+    }
+    if (clicks.hasClicks) {
+      factors++;
+      let clickScore = 0.5;
+      if (clicks.intervalVariance > 5e4) clickScore += 0.15;
+      else if (clicks.intervalVariance < 100) clickScore -= 0.2;
+      score += Math.max(0, Math.min(1, clickScore)) - 0.5;
+    }
+    if (factors === 0) return 0.3;
+    return Math.max(0, Math.min(1, score));
+  }
+  variance(values) {
+    if (values.length < 2) return 0;
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    return values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (values.length - 1);
+  }
+};
+
+// src/fingerprint/vpn-detection.ts
+async function detectVPN() {
+  const signals = {
+    webrtcLeak: null,
+    timezoneIPMismatch: false,
+    dnsLeak: null,
+    connectionType: null,
+    multipleIPs: false,
+    torBrowser: false,
+    knownVPNExtension: false
+  };
+  let confidence = 0;
+  let vpnDetected = false;
+  let proxyDetected = false;
+  let torDetected = false;
+  signals.torBrowser = detectTorBrowser();
+  if (signals.torBrowser) {
+    torDetected = true;
+    confidence += 0.9;
+  }
+  try {
+    signals.webrtcLeak = await detectWebRTCLeak();
+    if (signals.webrtcLeak) {
+      vpnDetected = true;
+      confidence += 0.3;
+    }
+  } catch {
+    signals.webrtcLeak = null;
+  }
+  signals.connectionType = getConnectionType2();
+  if (signals.connectionType === "unknown" || signals.connectionType === null) {
+    confidence += 0.05;
+  }
+  signals.knownVPNExtension = detectVPNExtensions();
+  if (signals.knownVPNExtension) {
+    vpnDetected = true;
+    confidence += 0.4;
+  }
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const lang = navigator.language;
+  if (tz && lang) {
+    const tzCountry = getTimezoneCountry(tz);
+    const langCountry = lang.split("-")[1]?.toUpperCase();
+    if (tzCountry && langCountry && tzCountry !== langCountry) {
+      signals.timezoneIPMismatch = true;
+      confidence += 0.1;
+    }
+  }
+  confidence = Math.min(confidence, 1);
+  if (confidence < 0.3) {
+    vpnDetected = false;
+    proxyDetected = false;
+  }
+  return {
+    vpnDetected,
+    proxyDetected,
+    torDetected,
+    confidence,
+    signals
+  };
+}
+function detectTorBrowser() {
+  if (typeof window === "undefined") return false;
+  const checks = [];
+  checks.push(window.screen.width === 1e3 && window.screen.height === 1e3);
+  checks.push(!window.MediaDevices);
+  checks.push(navigator.plugins.length === 0);
+  checks.push((/* @__PURE__ */ new Date()).getTimezoneOffset() === 0);
+  const ua = navigator.userAgent;
+  checks.push(ua.includes("Firefox") && !ua.includes("Chrome"));
+  const score = checks.filter(Boolean).length;
+  return score >= 3;
+}
+async function detectWebRTCLeak() {
+  if (typeof window === "undefined" || !window.RTCPeerConnection) {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => resolve(false), 3e3);
+    const localIPs = /* @__PURE__ */ new Set();
+    try {
+      const pc = new RTCPeerConnection({
+        iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
+      });
+      pc.createDataChannel("");
+      pc.onicecandidate = (event) => {
+        if (!event.candidate) {
+          clearTimeout(timeout);
+          pc.close();
+          resolve(localIPs.size > 1);
+          return;
+        }
+        const candidate = event.candidate.candidate;
+        const ipMatch = candidate.match(/(\d{1,3}\.){3}\d{1,3}/);
+        if (ipMatch) {
+          localIPs.add(ipMatch[0]);
+        }
+      };
+      pc.createOffer().then((offer) => pc.setLocalDescription(offer)).catch(() => {
+        clearTimeout(timeout);
+        resolve(false);
+      });
+    } catch {
+      clearTimeout(timeout);
+      resolve(false);
+    }
+  });
+}
+function getConnectionType2() {
+  if (typeof navigator === "undefined") return null;
+  const nav = navigator;
+  if (nav.connection) {
+    return nav.connection.type || nav.connection.effectiveType || null;
+  }
+  return null;
+}
+function detectVPNExtensions() {
+  if (typeof document === "undefined") return false;
+  const body = document.body;
+  if (!body) return false;
+  const vpnIndicators = [
+    "[data-windscribe]",
+    "[data-nord]",
+    ".surfshark-extension",
+    "#vpn-indicator",
+    "[data-expressvpn]"
+  ];
+  for (const selector of vpnIndicators) {
+    try {
+      if (document.querySelector(selector)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function getTimezoneCountry(tz) {
+  const tzMap = {
+    "America/New_York": "US",
+    "America/Chicago": "US",
+    "America/Denver": "US",
+    "America/Los_Angeles": "US",
+    "Europe/London": "GB",
+    "Europe/Paris": "FR",
+    "Europe/Berlin": "DE",
+    "Europe/Madrid": "ES",
+    "Europe/Rome": "IT",
+    "Asia/Tokyo": "JP",
+    "Asia/Shanghai": "CN",
+    "Asia/Kolkata": "IN",
+    "Asia/Seoul": "KR",
+    "Australia/Sydney": "AU",
+    "America/Toronto": "CA",
+    "America/Sao_Paulo": "BR",
+    "America/Mexico_City": "MX"
+  };
+  return tzMap[tz] || null;
+}
+
+// src/fingerprint/manager.ts
+var DEFAULT_ENDPOINT5 = "https://ingest.sitepong.com";
+var CACHE_KEY = "sitepong_visitor";
+var CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var COOKIE_NAME = "__sp_vid";
+var COOKIE_MAX_AGE = 63072e3;
+var FingerprintManager = class {
+  constructor(config) {
+    this.cachedVisitor = null;
+    this.pendingRequest = null;
+    this.config = {
+      endpoint: DEFAULT_ENDPOINT5,
+      enabled: true,
+      debug: false,
+      ...config
+    };
+    this.behaviorAnalyzer = new BehaviorAnalyzer();
+    if (this.config.enabled && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+      this.behaviorAnalyzer.start();
+    }
+    this.loadFromStorage();
+  }
+  async getVisitorId() {
+    if (!this.config.enabled) {
+      throw new Error("Fingerprint is not enabled");
+    }
+    isReactNative() ? getNativeDeviceId() : null;
+    if (this.cachedVisitor && !this.isCacheExpired()) {
+      this.log("Returning cached visitor ID:", this.cachedVisitor.result.visitorId);
+      return this.cachedVisitor.result;
+    }
+    if (this.pendingRequest) {
+      return this.pendingRequest;
+    }
+    this.pendingRequest = this.fetchVisitorId();
+    try {
+      const result = await this.pendingRequest;
+      return result;
+    } finally {
+      this.pendingRequest = null;
+    }
+  }
+  async getDeviceSignals() {
+    return collectDeviceSignals(this.config.extendedSignals ?? false);
+  }
+  async getFraudCheck() {
+    const [visitorResult, signals, vpnResult] = await Promise.all([
+      this.getVisitorId(),
+      this.getDeviceSignals(),
+      detectVPN().catch(() => null)
+    ]);
+    const behaviorMetrics = this.behaviorAnalyzer.getMetrics();
+    signals.behavior = {
+      score: behaviorMetrics.score,
+      mouseMovements: behaviorMetrics.mouse.totalMovements,
+      keystrokes: behaviorMetrics.keyboard.totalKeystrokes,
+      scrolls: behaviorMetrics.scroll.totalScrolls,
+      clicks: behaviorMetrics.clicks.totalClicks,
+      isHuman: behaviorMetrics.score > 0.6
+    };
+    const vpnDetected = vpnResult?.vpnDetected || vpnResult?.torDetected || false;
+    return {
+      visitorId: visitorResult.visitorId,
+      riskScore: this.calculateRiskScore(signals, vpnDetected),
+      signals,
+      flags: {
+        incognito: signals.smart?.incognito || signals.incognito,
+        bot: signals.smart?.bot || signals.bot || !signals.behavior.isHuman,
+        vpn: vpnDetected || signals.smart?.timezoneMismatch,
+        tampered: signals.smart?.privacyBrowser
+      }
+    };
+  }
+  stopBehaviorTracking() {
+    this.behaviorAnalyzer.stop();
+  }
+  async fetchVisitorId() {
+    const signals = await this.getDeviceSignals();
+    const stableFingerprint = await getStableFingerprint(signals);
+    const endpoint = this.config.visitorEndpoint || `${this.config.endpoint}/api/visitors`;
+    const previousVisitorId = this.getCookieVisitorId() || this.cachedVisitor?.result.visitorId || void 0;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        },
+        credentials: "include",
+        body: JSON.stringify({
+          signals,
+          stableFingerprint,
+          previousVisitorId
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const result = await response.json();
+      this.cachedVisitor = {
+        result,
+        signals,
+        cachedAt: Date.now()
+      };
+      this.saveToStorage();
+      this.setCookieVisitorId(result.visitorId);
+      this.log("Visitor ID fetched:", result.visitorId);
+      return result;
+    } catch (err) {
+      this.log("Failed to fetch visitor ID:", err);
+      throw err;
+    }
+  }
+  calculateRiskScore(signals, vpnDetected = false) {
+    let score = 0;
+    const smart = signals.smart;
+    if (smart?.bot || signals.bot) score += 0.8;
+    if (signals.behavior) {
+      if (signals.behavior.score < 0.3) score += 0.4;
+      else if (signals.behavior.score < 0.5) score += 0.2;
+    }
+    if (vpnDetected) score += 0.25;
+    if (smart?.incognito || signals.incognito) score += 0.2;
+    if (smart?.devToolsOpen) score += 0.1;
+    if (smart?.privacyBrowser) score += 0.1;
+    if (signals.hardwareConcurrency === 0) score += 0.1;
+    if (signals.maxTouchPoints === 0 && /mobile|android|iphone/i.test(signals.userAgent)) {
+      score += 0.15;
+    }
+    if (!signals.cookieEnabled) score += 0.1;
+    if (smart?.doNotTrack) score += 0.05;
+    if (smart?.deviceVisitCount === 1) score += 0.05;
+    return Math.round(Math.min(score, 1) * 100) / 100;
+  }
+  isCacheExpired() {
+    if (!this.cachedVisitor) return true;
+    return Date.now() - this.cachedVisitor.cachedAt > CACHE_TTL_MS;
+  }
+  loadFromStorage() {
+    if (typeof window === "undefined" || typeof localStorage === "undefined") return;
+    try {
+      const stored = localStorage.getItem(CACHE_KEY);
+      if (!stored) return;
+      const parsed = JSON.parse(stored);
+      if (!this.isCacheExpiredAt(parsed.cachedAt)) {
+        this.cachedVisitor = parsed;
+        this.log("Loaded cached visitor from storage");
+      } else {
+        localStorage.removeItem(CACHE_KEY);
+      }
+    } catch {
+    }
+  }
+  saveToStorage() {
+    if (typeof window === "undefined" || typeof localStorage === "undefined") return;
+    if (!this.cachedVisitor) return;
+    try {
+      localStorage.setItem(CACHE_KEY, JSON.stringify(this.cachedVisitor));
+    } catch {
+    }
+  }
+  isCacheExpiredAt(cachedAt) {
+    return Date.now() - cachedAt > CACHE_TTL_MS;
+  }
+  getCookieVisitorId() {
+    if (typeof document === "undefined") return void 0;
+    try {
+      const match = document.cookie.match(new RegExp(`(?:^|; )${COOKIE_NAME}=([^;]*)`));
+      return match?.[1] || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  setCookieVisitorId(visitorId) {
+    if (typeof document === "undefined") return;
+    try {
+      document.cookie = `${COOKIE_NAME}=${visitorId}; path=/; max-age=${COOKIE_MAX_AGE}; SameSite=Lax`;
+    } catch {
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong Fingerprint]", ...args);
+    }
+  }
+};
+var DEFAULT_ENDPOINT6 = "https://ingest.sitepong.com";
+var DEFAULT_FLUSH_INTERVAL3 = 1e4;
+var MAX_FLUSH_FAILURES4 = 3;
+var MAX_RESOURCES_PER_FLUSH = 200;
+var PAGE_TIMING_POLL_INTERVAL = 200;
+var PAGE_TIMING_TIMEOUT = 3e4;
+function getPaintBlocks(resources) {
+  const paintBlocks = [];
+  const elements = document.getElementsByTagName("*");
+  const styleURL = /url\(("[^"]*"|'[^']*'|[^)]*)\)/i;
+  for (let i = 0; i < elements.length; i++) {
+    const element = elements[i];
+    let src = "";
+    if (element.tagName === "IMG") {
+      src = element.currentSrc || element.src;
+    }
+    if (!src) {
+      const backgroundImage = getComputedStyle(element).getPropertyValue("background-image");
+      if (backgroundImage) {
+        const matches = styleURL.exec(backgroundImage);
+        if (matches !== null) {
+          src = matches[1];
+          if (src.startsWith('"') || src.startsWith("'")) {
+            src = src.substr(1, src.length - 2);
+          }
+        }
+      }
+    }
+    if (!src) continue;
+    const time = src.substr(0, 10) === "data:image" ? 0 : resources[src];
+    if (time === void 0) continue;
+    const rect = element.getBoundingClientRect();
+    const top = Math.max(rect.top, 0);
+    const left = Math.max(rect.left, 0);
+    const bottom = Math.min(
+      rect.bottom,
+      window.innerHeight || document.documentElement && document.documentElement.clientHeight || 0
+    );
+    const right = Math.min(
+      rect.right,
+      window.innerWidth || document.documentElement && document.documentElement.clientWidth || 0
+    );
+    if (bottom <= top || right <= left) continue;
+    const area = (bottom - top) * (right - left);
+    paintBlocks.push({ time, area });
+  }
+  return paintBlocks;
+}
+function calculateSpeedIndex(firstContentfulPaint, paintBlocks) {
+  let a = Math.max(
+    document.documentElement && document.documentElement.clientWidth || 0,
+    window.innerWidth || 0
+  ) * Math.max(
+    document.documentElement && document.documentElement.clientHeight || 0,
+    window.innerHeight || 0
+  ) / 10;
+  let s = a * firstContentfulPaint;
+  for (let i = 0; i < paintBlocks.length; i++) {
+    const { time, area } = paintBlocks[i];
+    a += area;
+    s += area * (time > firstContentfulPaint ? time : firstContentfulPaint);
+  }
+  return a === 0 ? 0 : s / a;
+}
+var PerformanceManager = class {
+  constructor(config) {
+    this.metrics = [];
+    this.flushTimer = null;
+    this.flushFailures = 0;
+    this.disabled = false;
+    this.vitals = {};
+    this.activeTransactions = /* @__PURE__ */ new Map();
+    // Resource timing state for Speed Index
+    this.resourceObserver = null;
+    this.resourceTimeMap = {};
+    this.resourceCount = 0;
+    // Page timing polling timers
+    this.pageLoadTimer = null;
+    this.pageRenderTimer = null;
+    this.config = {
+      endpoint: DEFAULT_ENDPOINT6,
+      enabled: true,
+      webVitals: true,
+      navigationTiming: true,
+      resourceTiming: true,
+      capturePageLoadTimings: true,
+      capturePageRenderTimings: true,
+      excludedResourceUrls: [],
+      flushInterval: DEFAULT_FLUSH_INTERVAL3,
+      sampleRate: 1,
+      debug: false,
+      ...config
+    };
+    this.sampled = Math.random() <= this.config.sampleRate;
+  }
+  init() {
+    if (!this.config.enabled || !this.sampled) return;
+    if (typeof window === "undefined" || typeof window.addEventListener !== "function") return;
+    if (this.config.webVitals !== false) {
+      this.initWebVitals();
+    }
+    if (this.config.resourceTiming !== false) {
+      this.initResourceTiming();
+    }
+    if (this.config.capturePageLoadTimings !== false) {
+      this.initPageLoadTiming();
+    }
+    if (this.config.capturePageRenderTimings !== false) {
+      this.initPageRenderTiming();
+    }
+    this.startFlushTimer();
+    this.log("Performance monitoring initialized");
+  }
+  // ---- Web Vitals (via web-vitals library) ----
+  initWebVitals() {
+    onCLS((m) => {
+      this.vitals.cls = m.value;
+      this.reportVital("CLS", m.value, "score");
+    });
+    onINP((m) => {
+      this.vitals.inp = m.value;
+      this.reportVital("INP", m.value);
+    });
+    onLCP((m) => {
+      this.vitals.lcp = m.value;
+      this.reportVital("LCP", m.value);
+    });
+    onTTFB((m) => {
+      this.vitals.ttfb = m.value;
+      this.reportVital("TTFB", m.value);
+    });
+    onFCP((m) => {
+      this.vitals.fcp = m.value;
+      this.reportVital("FCP", m.value);
+    });
+  }
+  // ---- Resource Timing (adapted from OpenReplay timing.ts) ----
+  initResourceTiming() {
+    if (typeof PerformanceObserver === "undefined") return;
+    try {
+      this.resourceObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          this.processResourceEntry(entry);
+        }
+      });
+      this.resourceObserver.observe({ type: "resource", buffered: true });
+    } catch {
+      this.log("PerformanceObserver for resource timing not supported");
+    }
+  }
+  isServiceURL(url) {
+    const endpoint = this.config.performanceEndpoint || this.config.endpoint;
+    return url.startsWith(endpoint);
+  }
+  processResourceEntry(entry) {
+    if (entry.duration < 0 || !entry.name.startsWith("http")) return;
+    if (this.isServiceURL(entry.name)) return;
+    if (this.resourceTimeMap !== null) {
+      this.resourceTimeMap[entry.name] = entry.startTime + entry.duration;
+    }
+    for (const excluded of this.config.excludedResourceUrls) {
+      if (entry.name.startsWith(excluded)) return;
+    }
+    if (this.resourceCount >= MAX_RESOURCES_PER_FLUSH) return;
+    this.resourceCount++;
+    let stalled = 0;
+    if (entry.connectEnd && entry.connectEnd > entry.domainLookupEnd) {
+      stalled = Math.max(0, entry.requestStart - entry.connectEnd);
+    } else {
+      stalled = Math.max(0, entry.requestStart - entry.domainLookupEnd);
+    }
+    const cached = entry.responseStatus && entry.responseStatus === 304 || entry.deliveryType && entry.deliveryType === "cache" || entry.transferSize === 0 && entry.decodedBodySize > 0;
+    const responseStatus = entry.responseStatus || 0;
+    const failed = responseStatus >= 400;
+    const breakdown = {
+      queueing: entry.requestStart - entry.fetchStart,
+      dnsLookup: entry.domainLookupEnd - entry.domainLookupStart,
+      initialConnection: entry.connectEnd - entry.connectStart,
+      ssl: entry.secureConnectionStart > 0 ? entry.connectEnd - entry.secureConnectionStart : 0,
+      ttfb: entry.responseStart - entry.requestStart,
+      contentDownload: entry.responseEnd - entry.responseStart,
+      total: entry.duration ?? entry.responseEnd - entry.startTime,
+      stalled,
+      cached,
+      failed,
+      responseStatus,
+      headerSize: entry.transferSize > entry.encodedBodySize ? entry.transferSize - entry.encodedBodySize : 0,
+      encodedBodySize: entry.encodedBodySize || 0,
+      decodedBodySize: failed ? -111 : entry.decodedBodySize || 0,
+      transferSize: entry.transferSize,
+      initiatorType: entry.initiatorType
+    };
+    const entryName = this.config.resourceNameSanitizer ? this.config.resourceNameSanitizer(entry.name) : entry.name;
+    this.addMetric({
+      type: "resource",
+      name: entryName,
+      value: entry.duration,
+      unit: "ms",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      url: typeof window !== "undefined" && window.location ? window.location.href : void 0,
+      data: breakdown
+    });
+  }
+  // ---- Page Load Timing (adapted from OpenReplay timing.ts) ----
+  initPageLoadTiming() {
+    if (typeof window === "undefined" || !window.performance) return;
+    let firstPaint = 0;
+    let firstContentfulPaint = 0;
+    let sent = false;
+    const startTime = performance.now();
+    this.pageLoadTimer = setInterval(() => {
+      if (sent) {
+        if (this.pageLoadTimer) clearInterval(this.pageLoadTimer);
+        return;
+      }
+      if (firstPaint === 0 || firstContentfulPaint === 0) {
+        for (const entry of performance.getEntriesByType("paint")) {
+          if (entry.name === "first-paint") firstPaint = entry.startTime;
+          if (entry.name === "first-contentful-paint") firstContentfulPaint = entry.startTime;
+        }
+      }
+      const nav = performance.getEntriesByType("navigation")[0];
+      const timedOut = performance.now() - startTime > PAGE_TIMING_TIMEOUT;
+      if (nav && nav.loadEventEnd > 0 || timedOut) {
+        sent = true;
+        if (this.pageLoadTimer) clearInterval(this.pageLoadTimer);
+        if (nav) {
+          const navigationStart = nav.startTime;
+          this.addMetric({
+            type: "navigation",
+            name: "page_load",
+            value: nav.loadEventEnd - navigationStart,
+            unit: "ms",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            url: window.location.href,
+            data: {
+              requestStart: nav.requestStart - navigationStart,
+              responseStart: nav.responseStart - navigationStart,
+              responseEnd: nav.responseEnd - navigationStart,
+              domContentLoadedEventStart: nav.domContentLoadedEventEnd - navigationStart,
+              domContentLoadedEventEnd: nav.domContentLoadedEventEnd - navigationStart,
+              loadEventStart: nav.loadEventStart - navigationStart,
+              loadEventEnd: nav.loadEventEnd - navigationStart,
+              firstPaint,
+              firstContentfulPaint,
+              dns: nav.domainLookupEnd - nav.domainLookupStart,
+              tcp: nav.connectEnd - nav.connectStart,
+              ttfb: nav.responseStart - nav.requestStart,
+              domComplete: nav.domComplete - navigationStart,
+              transferSize: nav.transferSize,
+              encodedBodySize: nav.encodedBodySize,
+              decodedBodySize: nav.decodedBodySize
+            }
+          });
+        }
+      }
+    }, PAGE_TIMING_POLL_INTERVAL);
+  }
+  // ---- Page Render Timing: Speed Index, Visually Complete, TTI (adapted from OpenReplay) ----
+  initPageRenderTiming() {
+    if (typeof window === "undefined" || !window.performance) return;
+    let firstContentfulPaint = 0;
+    let visuallyComplete = 0;
+    let interactiveWindowStartTime = 0;
+    let interactiveWindowTickTime = 0;
+    let paintBlocks = null;
+    let sent = false;
+    const startTime = performance.now();
+    this.pageRenderTimer = setInterval(() => {
+      if (sent) {
+        if (this.pageRenderTimer) clearInterval(this.pageRenderTimer);
+        return;
+      }
+      const time = performance.now();
+      if (firstContentfulPaint === 0) {
+        for (const entry of performance.getEntriesByType("paint")) {
+          if (entry.name === "first-contentful-paint") {
+            firstContentfulPaint = entry.startTime;
+          }
+        }
+      }
+      if (this.resourceTimeMap !== null) {
+        const times = Object.values(this.resourceTimeMap);
+        if (times.length > 0) {
+          visuallyComplete = Math.max(...times);
+        }
+        if (time - visuallyComplete > 1e3) {
+          paintBlocks = getPaintBlocks(this.resourceTimeMap);
+          this.resourceTimeMap = null;
+        }
+      }
+      if (interactiveWindowTickTime !== null) {
+        if (time - interactiveWindowTickTime > 50) {
+          interactiveWindowStartTime = time;
+        }
+        interactiveWindowTickTime = time - interactiveWindowStartTime > 5e3 ? null : time;
+      }
+      const timedOut = time - startTime > PAGE_TIMING_TIMEOUT;
+      if (paintBlocks !== null && interactiveWindowTickTime === null || timedOut) {
+        sent = true;
+        if (this.pageRenderTimer) clearInterval(this.pageRenderTimer);
+        this.resourceTimeMap = null;
+        const speedIndex = paintBlocks === null ? 0 : calculateSpeedIndex(firstContentfulPaint || 0, paintBlocks);
+        const nav = performance.getEntriesByType("navigation")[0];
+        const domContentLoadedEnd = nav ? nav.domContentLoadedEventEnd - nav.startTime : 0;
+        const timeToInteractive = interactiveWindowTickTime === null ? Math.max(interactiveWindowStartTime, firstContentfulPaint, domContentLoadedEnd) : 0;
+        const url = window.location.href;
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        if (speedIndex > 0) {
+          this.addMetric({
+            type: "page_render",
+            name: "speed_index",
+            value: Math.round(speedIndex),
+            unit: "ms",
+            timestamp,
+            url
+          });
+        }
+        if (visuallyComplete > 0) {
+          this.addMetric({
+            type: "page_render",
+            name: "visually_complete",
+            value: Math.round(visuallyComplete),
+            unit: "ms",
+            timestamp,
+            url
+          });
+        }
+        if (timeToInteractive > 0) {
+          this.addMetric({
+            type: "page_render",
+            name: "tti",
+            value: Math.round(timeToInteractive),
+            unit: "ms",
+            timestamp,
+            url
+          });
+        }
+      }
+    }, PAGE_TIMING_POLL_INTERVAL);
+  }
+  // ---- Transactions / Spans (unchanged) ----
+  startTransaction(name, data) {
+    const id = `txn_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+    const transaction = {
+      id,
+      name,
+      startTime: performance.now(),
+      status: "running",
+      spans: [],
+      data
+    };
+    this.activeTransactions.set(id, transaction);
+    this.log("Transaction started:", name, id);
+    return id;
   }
-  analyzeMouseMovement() {
-    if (this.mousePoints.length < 3) {
-      return {
-        totalMovements: this.mousePoints.length,
-        averageSpeed: 0,
-        maxSpeed: 0,
-        averageAcceleration: 0,
-        straightLineRatio: 0,
-        jitter: 0,
-        hasMovement: false
-      };
+  endTransaction(id, status = "ok") {
+    const transaction = this.activeTransactions.get(id);
+    if (!transaction) {
+      this.log("Transaction not found:", id);
+      return;
     }
-    const speeds = [];
-    const accelerations = [];
-    let straightSegments = 0;
-    let totalSegments = 0;
-    let jitterSum = 0;
-    for (let i = 1; i < this.mousePoints.length; i++) {
-      const prev = this.mousePoints[i - 1];
-      const curr = this.mousePoints[i];
-      const dt = curr.t - prev.t || 1;
-      const dx = curr.x - prev.x;
-      const dy = curr.y - prev.y;
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      const speed = distance / dt;
-      speeds.push(speed);
-      if (distance < 3 && distance > 0) {
-        jitterSum++;
-      }
-      if (i >= 2) {
-        const pp = this.mousePoints[i - 2];
-        const expectedX = pp.x + (curr.x - pp.x) * ((prev.t - pp.t) / (curr.t - pp.t));
-        const expectedY = pp.y + (curr.y - pp.y) * ((prev.t - pp.t) / (curr.t - pp.t));
-        const deviation = Math.sqrt((prev.x - expectedX) ** 2 + (prev.y - expectedY) ** 2);
-        totalSegments++;
-        if (deviation < 2) straightSegments++;
-      }
-      if (i >= 2) {
-        const prevSpeed = speeds[speeds.length - 2] || 0;
-        accelerations.push(Math.abs(speed - prevSpeed) / dt);
+    transaction.endTime = performance.now();
+    transaction.duration = transaction.endTime - transaction.startTime;
+    transaction.status = status;
+    for (const span of transaction.spans) {
+      if (span.status === "running") {
+        span.endTime = transaction.endTime;
+        span.duration = span.endTime - span.startTime;
+        span.status = status;
       }
     }
-    const avgSpeed = speeds.reduce((a, b) => a + b, 0) / speeds.length;
-    const maxSpeed = Math.max(...speeds);
-    const avgAccel = accelerations.length > 0 ? accelerations.reduce((a, b) => a + b, 0) / accelerations.length : 0;
-    return {
-      totalMovements: this.mousePoints.length,
-      averageSpeed: Math.round(avgSpeed * 1e3) / 1e3,
-      maxSpeed: Math.round(maxSpeed * 1e3) / 1e3,
-      averageAcceleration: Math.round(avgAccel * 1e3) / 1e3,
-      straightLineRatio: totalSegments > 0 ? straightSegments / totalSegments : 0,
-      jitter: this.mousePoints.length > 0 ? jitterSum / this.mousePoints.length : 0,
-      hasMovement: true
-    };
+    this.activeTransactions.delete(id);
+    this.addMetric({
+      type: "transaction",
+      name: transaction.name,
+      value: transaction.duration,
+      unit: "ms",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      url: typeof window !== "undefined" && window.location ? window.location.href : void 0,
+      transaction
+    });
+    this.log("Transaction ended:", transaction.name, `${transaction.duration.toFixed(1)}ms`);
   }
-  analyzeKeyboard() {
-    if (this.keyIntervals.length < 2) {
-      return {
-        totalKeystrokes: this.keyIntervals.length,
-        averageInterval: 0,
-        intervalVariance: 0,
-        holdTimeAverage: 0,
-        holdTimeVariance: 0,
-        hasKeystrokes: false
-      };
+  startSpan(transactionId, name, data) {
+    const transaction = this.activeTransactions.get(transactionId);
+    if (!transaction) {
+      this.log("Transaction not found for span:", transactionId);
+      return "";
     }
-    const avgInterval = this.keyIntervals.reduce((a, b) => a + b, 0) / this.keyIntervals.length;
-    const intervalVar = this.variance(this.keyIntervals);
-    const avgHold = this.keyHoldTimes.length > 0 ? this.keyHoldTimes.reduce((a, b) => a + b, 0) / this.keyHoldTimes.length : 0;
-    const holdVar = this.keyHoldTimes.length > 0 ? this.variance(this.keyHoldTimes) : 0;
-    return {
-      totalKeystrokes: this.keyIntervals.length + 1,
-      averageInterval: Math.round(avgInterval),
-      intervalVariance: Math.round(intervalVar),
-      holdTimeAverage: Math.round(avgHold),
-      holdTimeVariance: Math.round(holdVar),
-      hasKeystrokes: true
+    const span = {
+      id: `span_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`,
+      name,
+      startTime: performance.now(),
+      status: "running",
+      data
     };
+    transaction.spans.push(span);
+    return span.id;
   }
-  analyzeScroll() {
-    if (this.scrollEvents.length < 2) {
-      return { totalScrolls: this.scrollEvents.length, averageSpeed: 0, smoothness: 0, hasScroll: false };
+  endSpan(transactionId, spanId, status = "ok") {
+    const transaction = this.activeTransactions.get(transactionId);
+    if (!transaction) return;
+    const span = transaction.spans.find((s) => s.id === spanId);
+    if (!span) return;
+    span.endTime = performance.now();
+    span.duration = span.endTime - span.startTime;
+    span.status = status;
+  }
+  // ---- Public API ----
+  getVitals() {
+    return { ...this.vitals };
+  }
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
     }
-    const speeds = [];
-    for (let i = 1; i < this.scrollEvents.length; i++) {
-      const dt = this.scrollEvents[i].t - this.scrollEvents[i - 1].t || 1;
-      const dy = Math.abs(this.scrollEvents[i].deltaY - this.scrollEvents[i - 1].deltaY);
-      speeds.push(dy / dt);
+    if (this.pageLoadTimer) {
+      clearInterval(this.pageLoadTimer);
+      this.pageLoadTimer = null;
     }
-    const avgSpeed = speeds.reduce((a, b) => a + b, 0) / speeds.length;
-    const speedVar = this.variance(speeds);
-    const smoothness = avgSpeed > 0 ? Math.min(1, avgSpeed / (speedVar + avgSpeed)) : 0;
-    return {
-      totalScrolls: this.scrollEvents.length,
-      averageSpeed: Math.round(avgSpeed * 100) / 100,
-      smoothness: Math.round(smoothness * 100) / 100,
-      hasScroll: true
-    };
-  }
-  analyzeClicks() {
-    if (this.clickTimes.length < 2) {
-      return {
-        totalClicks: this.clickTimes.length,
-        averageInterval: 0,
-        intervalVariance: 0,
-        doubleClickCount: 0,
-        hasClicks: this.clickTimes.length > 0
-      };
+    if (this.pageRenderTimer) {
+      clearInterval(this.pageRenderTimer);
+      this.pageRenderTimer = null;
     }
-    const intervals = [];
-    let doubleClicks = 0;
-    for (let i = 1; i < this.clickTimes.length; i++) {
-      const interval = this.clickTimes[i] - this.clickTimes[i - 1];
-      intervals.push(interval);
-      if (interval < 500) doubleClicks++;
+    if (this.resourceObserver) {
+      this.resourceObserver.disconnect();
+      this.resourceObserver = null;
     }
-    const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
-    const intervalVar = this.variance(intervals);
-    return {
-      totalClicks: this.clickTimes.length,
-      averageInterval: Math.round(avgInterval),
-      intervalVariance: Math.round(intervalVar),
-      doubleClickCount: doubleClicks,
-      hasClicks: true
-    };
+    this.flush();
   }
-  calculateHumanScore(mouse, keyboard, scroll, clicks) {
-    let score = 0.5;
-    let factors = 0;
-    if (mouse.hasMovement) {
-      factors++;
-      let mouseScore = 0.5;
-      if (mouse.jitter > 0.05) mouseScore += 0.15;
-      if (mouse.straightLineRatio < 0.5) mouseScore += 0.15;
-      else if (mouse.straightLineRatio > 0.9) mouseScore -= 0.2;
-      if (mouse.averageSpeed > 0 && mouse.maxSpeed / mouse.averageSpeed > 3) {
-        mouseScore += 0.1;
-      }
-      if (mouse.averageAcceleration > 0) mouseScore += 0.1;
-      score += Math.max(0, Math.min(1, mouseScore)) - 0.5;
+  // ---- Internal ----
+  reportVital(name, value, unit = "ms") {
+    this.addMetric({
+      type: "web_vital",
+      name,
+      value,
+      unit,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      url: typeof window !== "undefined" && window.location ? window.location.href : void 0
+    });
+  }
+  addMetric(metric) {
+    this.metrics.push(metric);
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.config.flushInterval);
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden") {
+          this.flush();
+        }
+      });
     }
-    if (keyboard.hasKeystrokes) {
-      factors++;
-      let keyScore = 0.5;
-      if (keyboard.intervalVariance > 1e3) keyScore += 0.2;
-      else if (keyboard.intervalVariance < 100) keyScore -= 0.2;
-      const cv = keyboard.averageInterval > 0 ? Math.sqrt(keyboard.intervalVariance) / keyboard.averageInterval : 0;
-      if (cv > 0.3) keyScore += 0.15;
-      if (keyboard.holdTimeVariance > 500) keyScore += 0.1;
-      score += Math.max(0, Math.min(1, keyScore)) - 0.5;
+  }
+  async flush() {
+    if (this.metrics.length === 0) return;
+    if (this.disabled) {
+      this.metrics = [];
+      return;
     }
-    if (scroll.hasScroll) {
-      factors++;
-      let scrollScore = 0.5;
-      if (scroll.smoothness > 0.3 && scroll.smoothness < 0.9) {
-        scrollScore += 0.2;
+    const metrics = [...this.metrics];
+    this.metrics = [];
+    this.resourceCount = 0;
+    const endpoint = this.config.performanceEndpoint || `${this.config.endpoint}/api/performance`;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        },
+        body: JSON.stringify({ metrics })
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      this.flushFailures = 0;
+      this.log(`Flushed ${metrics.length} performance metrics`);
+    } catch (err) {
+      this.flushFailures++;
+      if (this.flushFailures >= MAX_FLUSH_FAILURES4) {
+        this.disabled = true;
+        console.warn(
+          `[SitePong Performance] Disabled after ${MAX_FLUSH_FAILURES4} consecutive failures. Check that ${endpoint} is accessible and has proper CORS headers.`
+        );
+        return;
       }
-      score += Math.max(0, Math.min(1, scrollScore)) - 0.5;
-    }
-    if (clicks.hasClicks) {
-      factors++;
-      let clickScore = 0.5;
-      if (clicks.intervalVariance > 5e4) clickScore += 0.15;
-      else if (clicks.intervalVariance < 100) clickScore -= 0.2;
-      score += Math.max(0, Math.min(1, clickScore)) - 0.5;
+      this.metrics.unshift(...metrics);
+      this.log(`Failed to flush metrics (attempt ${this.flushFailures}/${MAX_FLUSH_FAILURES4}):`, err);
     }
-    if (factors === 0) return 0.3;
-    return Math.max(0, Math.min(1, score));
   }
-  variance(values) {
-    if (values.length < 2) return 0;
-    const mean = values.reduce((a, b) => a + b, 0) / values.length;
-    return values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (values.length - 1);
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong Performance]", ...args);
+    }
   }
 };
 
-// src/fingerprint/vpn-detection.ts
-async function detectVPN() {
-  const signals = {
-    webrtcLeak: null,
-    timezoneIPMismatch: false,
-    dnsLeak: null,
-    connectionType: null,
-    multipleIPs: false,
-    torBrowser: false,
-    knownVPNExtension: false
-  };
-  let confidence = 0;
-  let vpnDetected = false;
-  let proxyDetected = false;
-  let torDetected = false;
-  signals.torBrowser = detectTorBrowser();
-  if (signals.torBrowser) {
-    torDetected = true;
-    confidence += 0.9;
+// ../capture-core/dist/index.mjs
+var DHASH_WIDTH = 9;
+var DHASH_HEIGHT = 8;
+function toGray(r, g, b) {
+  return Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+}
+function rgbaToGray(rgba, width, height) {
+  const out = new Float64Array(width * height);
+  for (let i = 0; i < width * height; i++) {
+    const o = i * 4;
+    out[i] = toGray(rgba[o], rgba[o + 1], rgba[o + 2]);
   }
-  try {
-    signals.webrtcLeak = await detectWebRTCLeak();
-    if (signals.webrtcLeak) {
-      vpnDetected = true;
-      confidence += 0.3;
+  return out;
+}
+function bilinearResizeGray(src, srcW, srcH, dstW, dstH) {
+  const dst = new Float64Array(dstW * dstH);
+  const scaleX = srcW / dstW;
+  const scaleY = srcH / dstH;
+  for (let dy = 0; dy < dstH; dy++) {
+    let sy = (dy + 0.5) * scaleY - 0.5;
+    if (sy < 0) sy = 0;
+    if (sy > srcH - 1) sy = srcH - 1;
+    const y0 = Math.floor(sy);
+    const y1 = Math.min(y0 + 1, srcH - 1);
+    const wy = sy - y0;
+    for (let dx = 0; dx < dstW; dx++) {
+      let sx = (dx + 0.5) * scaleX - 0.5;
+      if (sx < 0) sx = 0;
+      if (sx > srcW - 1) sx = srcW - 1;
+      const x0 = Math.floor(sx);
+      const x1 = Math.min(x0 + 1, srcW - 1);
+      const wx = sx - x0;
+      const p00 = src[y0 * srcW + x0];
+      const p01 = src[y0 * srcW + x1];
+      const p10 = src[y1 * srcW + x0];
+      const p11 = src[y1 * srcW + x1];
+      const top = p00 + (p01 - p00) * wx;
+      const bottom = p10 + (p11 - p10) * wx;
+      dst[dy * dstW + dx] = top + (bottom - top) * wy;
+    }
+  }
+  return dst;
+}
+function dHash(rgba, width, height) {
+  if (width <= 0 || height <= 0) {
+    throw new Error(`dHash: invalid dimensions ${width}x${height}`);
+  }
+  if (rgba.length < width * height * 4) {
+    throw new Error(
+      `dHash: rgba length ${rgba.length} too short for ${width}x${height} (need ${width * height * 4})`
+    );
+  }
+  const gray = rgbaToGray(rgba, width, height);
+  const small = bilinearResizeGray(gray, width, height, DHASH_WIDTH, DHASH_HEIGHT);
+  const bytes = new Uint8Array(8);
+  for (let row = 0; row < DHASH_HEIGHT; row++) {
+    let byte = 0;
+    for (let c = 0; c < 8; c++) {
+      const left = small[row * DHASH_WIDTH + c];
+      const right = small[row * DHASH_WIDTH + c + 1];
+      const bit = left < right ? 1 : 0;
+      byte |= bit << 7 - c;
     }
-  } catch {
-    signals.webrtcLeak = null;
+    bytes[row] = byte;
   }
-  signals.connectionType = getConnectionType2();
-  if (signals.connectionType === "unknown" || signals.connectionType === null) {
-    confidence += 0.05;
+  let hex = "";
+  for (let i = 0; i < 8; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
   }
-  signals.knownVPNExtension = detectVPNExtensions();
-  if (signals.knownVPNExtension) {
-    vpnDetected = true;
-    confidence += 0.4;
+  return hex;
+}
+function popcount8(n) {
+  let count = 0;
+  while (n) {
+    n &= n - 1;
+    count++;
   }
-  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  const lang = navigator.language;
-  if (tz && lang) {
-    const tzCountry = getTimezoneCountry(tz);
-    const langCountry = lang.split("-")[1]?.toUpperCase();
-    if (tzCountry && langCountry && tzCountry !== langCountry) {
-      signals.timezoneIPMismatch = true;
-      confidence += 0.1;
+  return count;
+}
+function hamming(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`hamming: length mismatch (${a.length} vs ${b.length})`);
+  }
+  if (a.length % 2 !== 0) {
+    throw new Error(`hamming: hex string length must be even, got ${a.length}`);
+  }
+  let dist = 0;
+  for (let i = 0; i < a.length; i += 2) {
+    const byteA = parseInt(a.slice(i, i + 2), 16);
+    const byteB = parseInt(b.slice(i, i + 2), 16);
+    if (Number.isNaN(byteA) || Number.isNaN(byteB)) {
+      throw new Error(`hamming: invalid hex at offset ${i}`);
     }
+    dist += popcount8(byteA ^ byteB);
   }
-  confidence = Math.min(confidence, 1);
-  if (confidence < 0.3) {
-    vpnDetected = false;
-    proxyDetected = false;
+  return dist;
+}
+var HAMMING_THRESHOLD = 10;
+function screenFingerprint(screenName, pHashHex) {
+  return `${screenName}:${pHashHex}`;
+}
+function parseFingerprint(fp) {
+  const idx = fp.lastIndexOf(":");
+  if (idx < 0) {
+    throw new Error(`parseFingerprint: missing ':' in "${fp}"`);
   }
   return {
-    vpnDetected,
-    proxyDetected,
-    torDetected,
-    confidence,
-    signals
+    screenName: fp.slice(0, idx),
+    pHashHex: fp.slice(idx + 1)
   };
 }
-function detectTorBrowser() {
-  if (typeof window === "undefined") return false;
-  const checks = [];
-  checks.push(window.screen.width === 1e3 && window.screen.height === 1e3);
-  checks.push(!window.MediaDevices);
-  checks.push(navigator.plugins.length === 0);
-  checks.push((/* @__PURE__ */ new Date()).getTimezoneOffset() === 0);
-  const ua = navigator.userAgent;
-  checks.push(ua.includes("Firefox") && !ua.includes("Chrome"));
-  const score = checks.filter(Boolean).length;
-  return score >= 3;
+
+// src/analytics/tap-capture.ts
+var ZERO_HASH = "0000000000000000";
+var DEFAULT_MAX_BATCH = 50;
+var DEFAULT_FLUSH_INTERVAL4 = 1e4;
+var DEFAULT_TEMPLATE_THROTTLE = 1e3;
+var MAX_FLUSH_FAILURES5 = 3;
+var RASTER_MAX_WIDTH = 480;
+var DEFAULT_BLOCK_SELECTOR = "img, picture, video, canvas, iframe, [data-sp-mask]";
+var SS_SESSION_ID = "sitepong_wt_session_id";
+var SS_SEQUENCE = "sitepong_wt_seq";
+var SS_STARTED_AT = "sitepong_wt_started_at";
+var SS_START_SENT = "sitepong_wt_start_sent";
+function generateUuid() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
 }
-async function detectWebRTCLeak() {
-  if (typeof window === "undefined" || !window.RTCPeerConnection) {
-    return false;
+var SessionState = class {
+  constructor() {
+    this.memory = {};
   }
-  return new Promise((resolve) => {
-    const timeout = setTimeout(() => resolve(false), 3e3);
-    const localIPs = /* @__PURE__ */ new Set();
+  get(key) {
     try {
-      const pc = new RTCPeerConnection({
-        iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
-      });
-      pc.createDataChannel("");
-      pc.onicecandidate = (event) => {
-        if (!event.candidate) {
-          clearTimeout(timeout);
-          pc.close();
-          resolve(localIPs.size > 1);
-          return;
-        }
-        const candidate = event.candidate.candidate;
-        const ipMatch = candidate.match(/(\d{1,3}\.){3}\d{1,3}/);
-        if (ipMatch) {
-          localIPs.add(ipMatch[0]);
-        }
-      };
-      pc.createOffer().then((offer) => pc.setLocalDescription(offer)).catch(() => {
-        clearTimeout(timeout);
-        resolve(false);
-      });
+      if (typeof sessionStorage !== "undefined") {
+        return sessionStorage.getItem(key);
+      }
     } catch {
-      clearTimeout(timeout);
-      resolve(false);
     }
-  });
-}
-function getConnectionType2() {
-  if (typeof navigator === "undefined") return null;
-  const nav = navigator;
-  if (nav.connection) {
-    return nav.connection.type || nav.connection.effectiveType || null;
+    return this.memory[key] ?? null;
   }
-  return null;
-}
-function detectVPNExtensions() {
-  if (typeof document === "undefined") return false;
-  const body = document.body;
-  if (!body) return false;
-  const vpnIndicators = [
-    "[data-windscribe]",
-    "[data-nord]",
-    ".surfshark-extension",
-    "#vpn-indicator",
-    "[data-expressvpn]"
-  ];
-  for (const selector of vpnIndicators) {
+  set(key, value) {
     try {
-      if (document.querySelector(selector)) return true;
+      if (typeof sessionStorage !== "undefined") {
+        sessionStorage.setItem(key, value);
+        return;
+      }
     } catch {
     }
+    this.memory[key] = value;
   }
-  return false;
-}
-function getTimezoneCountry(tz) {
-  const tzMap = {
-    "America/New_York": "US",
-    "America/Chicago": "US",
-    "America/Denver": "US",
-    "America/Los_Angeles": "US",
-    "Europe/London": "GB",
-    "Europe/Paris": "FR",
-    "Europe/Berlin": "DE",
-    "Europe/Madrid": "ES",
-    "Europe/Rome": "IT",
-    "Asia/Tokyo": "JP",
-    "Asia/Shanghai": "CN",
-    "Asia/Kolkata": "IN",
-    "Asia/Seoul": "KR",
-    "Australia/Sydney": "AU",
-    "America/Toronto": "CA",
-    "America/Sao_Paulo": "BR",
-    "America/Mexico_City": "MX"
-  };
-  return tzMap[tz] || null;
-}
-
-// src/fingerprint/manager.ts
-var DEFAULT_ENDPOINT6 = "https://ingest.sitepong.com";
-var CACHE_KEY = "sitepong_visitor";
-var CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-var COOKIE_NAME = "__sp_vid";
-var COOKIE_MAX_AGE = 63072e3;
-var FingerprintManager = class {
-  constructor(config) {
-    this.cachedVisitor = null;
-    this.pendingRequest = null;
-    this.config = {
-      endpoint: DEFAULT_ENDPOINT6,
-      enabled: true,
-      debug: false,
-      ...config
-    };
-    this.behaviorAnalyzer = new BehaviorAnalyzer();
-    if (this.config.enabled && typeof window !== "undefined" && typeof window.addEventListener === "function") {
-      this.behaviorAnalyzer.start();
+  get sessionId() {
+    let id = this.get(SS_SESSION_ID);
+    if (!id) {
+      id = generateUuid();
+      this.set(SS_SESSION_ID, id);
+      this.set(SS_STARTED_AT, String(Date.now()));
+      this.set(SS_SEQUENCE, "0");
+      this.set(SS_START_SENT, "0");
+    }
+    return id;
+  }
+  get startedAt() {
+    const raw = this.get(SS_STARTED_AT);
+    const parsed = raw ? parseInt(raw, 10) : NaN;
+    return Number.isFinite(parsed) ? parsed : Date.now();
+  }
+  get startSent() {
+    return this.get(SS_START_SENT) === "1";
+  }
+  markStartSent() {
+    this.set(SS_START_SENT, "1");
+  }
+  nextSequence() {
+    const raw = this.get(SS_SEQUENCE);
+    const prev = raw ? parseInt(raw, 10) : 0;
+    const next = (Number.isFinite(prev) ? prev : 0) + 1;
+    this.set(SS_SEQUENCE, String(next));
+    return next;
+  }
+};
+var fetchTransport = async (url, body, opts) => {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: opts.headers,
+    body,
+    keepalive: opts.keepalive
+  });
+  return { ok: res.ok, status: res.status };
+};
+var WatchtowerWebCapture = class {
+  constructor(config) {
+    this.session = new SessionState();
+    this.queue = [];
+    this.flushTimer = null;
+    this.flushFailures = 0;
+    this.disabled = false;
+    this.active = false;
+    this.distinctId = null;
+    this.currentScreen = null;
+    // Autocapture wiring
+    this.detachAutocapture = null;
+    this.ownAutocapture = null;
+    // History patching
+    this.originalPushState = null;
+    this.originalReplaceState = null;
+    this.popstateHandler = null;
+    this.pagehideHandler = null;
+    // Fingerprint state (per-session, in memory)
+    this.fpCache = /* @__PURE__ */ new Map();
+    // screen_name -> screen_fp
+    this.uploadedFps = /* @__PURE__ */ new Set();
+    // spec §1.3 uploaded-fingerprint set
+    this.lastRasterAt = /* @__PURE__ */ new Map();
+    this.rasterInFlight = false;
+    this.config = { ...config };
+    this.transport = config.transport || fetchTransport;
+    this.rasterizer = config.rasterizer || null;
+  }
+  /**
+   * Start capturing. Pass the existing AutocaptureModule (via
+   * AnalyticsManager.getAutocaptureModule()) to reuse its click listener +
+   * selector resolution; when absent, a private clicks-only module is created.
+   */
+  start(source) {
+    if (this.active || typeof window === "undefined") return;
+    this.active = true;
+    if (!this.rasterizer) {
+      this.rasterizer = new DomRasterizer({
+        blockSelector: this.combinedBlockSelector(),
+        maskSelector: this.config.maskSelector,
+        maxWidth: RASTER_MAX_WIDTH
+      });
+    }
+    const sessionId = this.session.sessionId;
+    if (!this.session.startSent) {
+      this.enqueue(this.baseEvent("session_start"));
+      this.session.markStartSent();
+    }
+    this.log("Started (session", sessionId + ")");
+    this.currentScreen = this.pathname();
+    if (this.currentScreen !== null) {
+      const ev = this.baseEvent("screen_view");
+      ev.screen_name = this.currentScreen;
+      this.enqueue(ev);
+      this.scheduleFingerprint(this.currentScreen);
+    }
+    this.setupNavigationTracking();
+    this.setupPagehide();
+    this.startFlushTimer();
+    if (source) {
+      this.detachAutocapture = source.addListener((event) => this.onAutocaptureEvent(event));
+    } else {
+      this.ownAutocapture = new AutocaptureModule(
+        { clicks: true, forms: false, pageviews: false, debug: this.config.debug },
+        (event) => this.onAutocaptureEvent(event)
+      );
+      this.ownAutocapture.start();
     }
-    this.loadFromStorage();
   }
-  async getVisitorId() {
-    if (!this.config.enabled) {
-      throw new Error("Fingerprint is not enabled");
+  stop() {
+    if (!this.active) return;
+    this.active = false;
+    if (this.detachAutocapture) {
+      this.detachAutocapture();
+      this.detachAutocapture = null;
     }
-    isReactNative() ? getNativeDeviceId() : null;
-    if (this.cachedVisitor && !this.isCacheExpired()) {
-      this.log("Returning cached visitor ID:", this.cachedVisitor.result.visitorId);
-      return this.cachedVisitor.result;
+    if (this.ownAutocapture) {
+      this.ownAutocapture.stop();
+      this.ownAutocapture = null;
     }
-    if (this.pendingRequest) {
-      return this.pendingRequest;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
     }
-    this.pendingRequest = this.fetchVisitorId();
-    try {
-      const result = await this.pendingRequest;
-      return result;
-    } finally {
-      this.pendingRequest = null;
+    if (typeof window !== "undefined") {
+      if (this.popstateHandler) {
+        window.removeEventListener("popstate", this.popstateHandler);
+        this.popstateHandler = null;
+      }
+      if (this.pagehideHandler) {
+        window.removeEventListener("pagehide", this.pagehideHandler);
+        this.pagehideHandler = null;
+      }
+      if (this.originalPushState) {
+        window.history.pushState = this.originalPushState;
+        this.originalPushState = null;
+      }
+      if (this.originalReplaceState) {
+        window.history.replaceState = this.originalReplaceState;
+        this.originalReplaceState = null;
+      }
     }
+    void this.flush();
+    this.log("Stopped");
   }
-  async getDeviceSignals() {
-    return collectDeviceSignals(this.config.extendedSignals ?? false);
+  isActive() {
+    return this.active;
   }
-  async getFraudCheck() {
-    const [visitorResult, signals, vpnResult] = await Promise.all([
-      this.getVisitorId(),
-      this.getDeviceSignals(),
-      detectVPN().catch(() => null)
-    ]);
-    const behaviorMetrics = this.behaviorAnalyzer.getMetrics();
-    signals.behavior = {
-      score: behaviorMetrics.score,
-      mouseMovements: behaviorMetrics.mouse.totalMovements,
-      keystrokes: behaviorMetrics.keyboard.totalKeystrokes,
-      scrolls: behaviorMetrics.scroll.totalScrolls,
-      clicks: behaviorMetrics.clicks.totalClicks,
-      isHuman: behaviorMetrics.score > 0.6
+  getSessionId() {
+    return this.session.sessionId;
+  }
+  /** Stamped as distinct_id on every subsequent event (identify() feeds this). */
+  setDistinctId(distinctId) {
+    this.distinctId = distinctId;
+  }
+  // -------------------------------------------------------------------------
+  // Tap path (hot — record + enqueue only)
+  // -------------------------------------------------------------------------
+  onAutocaptureEvent(event) {
+    if (!this.active || event.type !== "click") return;
+    const p = event.properties;
+    const clientX = typeof p.$x === "number" ? p.$x : null;
+    const clientY = typeof p.$y === "number" ? p.$y : null;
+    if (clientX === null || clientY === null) return;
+    this.recordTap({
+      selector: typeof p.$selector === "string" ? p.$selector : "",
+      label: typeof p.$el_text === "string" && p.$el_text || typeof p.$aria_label === "string" && p.$aria_label || void 0,
+      role: typeof p.$el_role === "string" && p.$el_role || roleForTag(typeof p.$tag_name === "string" ? p.$tag_name : void 0),
+      clientX,
+      clientY
+    });
+  }
+  /** Record a tap. Coordinates are viewport CSS px; normalization happens here. */
+  recordTap(input) {
+    if (!this.active || typeof window === "undefined") return;
+    const vw = window.innerWidth || 1;
+    const vh = window.innerHeight || 1;
+    const screenName = this.pathname() ?? "/";
+    const ev = this.baseEvent("tap");
+    ev.screen_name = screenName;
+    ev.screen_fp = this.fpCache.get(screenName) ?? screenFingerprint(screenName, ZERO_HASH);
+    ev.element_id = input.selector || "unknown";
+    if (input.label) ev.element_label = input.label;
+    if (input.role) ev.element_role = input.role;
+    ev.x = clamp01(input.clientX / vw);
+    ev.y = clamp01(input.clientY / vh);
+    ev.viewport_w = vw;
+    ev.viewport_h = vh;
+    this.enqueue(ev);
+    this.scheduleFingerprint(screenName);
+  }
+  // -------------------------------------------------------------------------
+  // Navigation → screen_view
+  // -------------------------------------------------------------------------
+  setupNavigationTracking() {
+    if (typeof window === "undefined" || !window.history || typeof window.addEventListener !== "function") {
+      return;
+    }
+    const onNavigate = () => this.handleRouteChange();
+    this.popstateHandler = onNavigate;
+    window.addEventListener("popstate", this.popstateHandler);
+    const originalPushState = window.history.pushState.bind(window.history);
+    const originalReplaceState = window.history.replaceState.bind(window.history);
+    this.originalPushState = window.history.pushState;
+    this.originalReplaceState = window.history.replaceState;
+    window.history.pushState = (...args) => {
+      originalPushState(...args);
+      onNavigate();
     };
-    const vpnDetected = vpnResult?.vpnDetected || vpnResult?.torDetected || false;
+    window.history.replaceState = (...args) => {
+      originalReplaceState(...args);
+      onNavigate();
+    };
+  }
+  handleRouteChange() {
+    if (!this.active) return;
+    const next = this.pathname();
+    if (next === null || next === this.currentScreen) return;
+    const prev = this.currentScreen;
+    this.currentScreen = next;
+    const ev = this.baseEvent("screen_view");
+    ev.screen_name = next;
+    if (prev) ev.prev_screen_name = prev;
+    this.enqueue(ev);
+    this.scheduleFingerprint(next);
+  }
+  // -------------------------------------------------------------------------
+  // Session end / pagehide
+  // -------------------------------------------------------------------------
+  setupPagehide() {
+    if (typeof window === "undefined" || typeof window.addEventListener !== "function") return;
+    this.pagehideHandler = () => {
+      if (!this.active) return;
+      const ev = this.baseEvent("session_end");
+      ev.reason = "background";
+      ev.duration_ms = Math.max(0, Date.now() - this.session.startedAt);
+      this.enqueue(ev);
+      void this.flush({ keepalive: true });
+    };
+    window.addEventListener("pagehide", this.pagehideHandler);
+  }
+  // -------------------------------------------------------------------------
+  // Batching (spec §1.3 — 50 events / 10 s / pagehide)
+  // -------------------------------------------------------------------------
+  baseEvent(type) {
     return {
-      visitorId: visitorResult.visitorId,
-      riskScore: this.calculateRiskScore(signals, vpnDetected),
-      signals,
-      flags: {
-        incognito: signals.smart?.incognito || signals.incognito,
-        bot: signals.smart?.bot || signals.bot || !signals.behavior.isHuman,
-        vpn: vpnDetected || signals.smart?.timezoneMismatch,
-        tampered: signals.smart?.privacyBrowser
+      type,
+      session_id: this.session.sessionId,
+      sequence: this.session.nextSequence(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      platform: "web",
+      app_version: this.config.appVersion || void 0,
+      distinct_id: this.distinctId || void 0,
+      os_version: typeof navigator !== "undefined" && navigator.userAgent ? navigator.userAgent : void 0
+    };
+  }
+  enqueue(event) {
+    if (this.disabled) return;
+    this.queue.push(event);
+    if (this.queue.length >= (this.config.maxBatchSize ?? DEFAULT_MAX_BATCH)) {
+      void this.flush();
+    }
+  }
+  startFlushTimer() {
+    if (this.flushTimer) clearInterval(this.flushTimer);
+    this.flushTimer = setInterval(() => {
+      void this.flush();
+    }, this.config.flushInterval ?? DEFAULT_FLUSH_INTERVAL4);
+  }
+  async flush(opts) {
+    if (this.queue.length === 0) return;
+    if (this.disabled) {
+      this.queue = [];
+      return;
+    }
+    const events = this.queue;
+    this.queue = [];
+    try {
+      const res = await this.transport(
+        `${this.config.endpoint}/api/taps`,
+        JSON.stringify({ events }),
+        { headers: this.headers(), keepalive: opts?.keepalive }
+      );
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      this.flushFailures = 0;
+      this.log(`Flushed ${events.length} events`);
+    } catch (err) {
+      this.flushFailures++;
+      if (this.flushFailures >= MAX_FLUSH_FAILURES5) {
+        this.disabled = true;
+        this.queue = [];
+        this.log(`Disabled after ${MAX_FLUSH_FAILURES5} consecutive flush failures`);
+        return;
       }
+      this.queue.unshift(...events);
+      this.log(`Flush failed (attempt ${this.flushFailures}/${MAX_FLUSH_FAILURES5}):`, err);
+    }
+  }
+  headers() {
+    return {
+      "Content-Type": "application/json",
+      "X-Project-ID": this.config.projectId,
+      "X-API-Key": this.config.apiKey
     };
   }
-  stopBehaviorTracking() {
-    this.behaviorAnalyzer.stop();
+  // -------------------------------------------------------------------------
+  // Fingerprint pipeline (idle-gated, throttled, upload-on-miss)
+  // -------------------------------------------------------------------------
+  scheduleFingerprint(screenName) {
+    if (!this.active || this.disabled || !this.rasterizer) return;
+    const now = Date.now();
+    const last = this.lastRasterAt.get(screenName) ?? 0;
+    const throttle = this.config.templateThrottleMs ?? DEFAULT_TEMPLATE_THROTTLE;
+    if (now - last < throttle || this.rasterInFlight) return;
+    this.lastRasterAt.set(screenName, now);
+    idle(() => {
+      void this.captureFingerprint(screenName);
+    });
   }
-  async fetchVisitorId() {
-    const signals = await this.getDeviceSignals();
-    const stableFingerprint = await getStableFingerprint(signals);
-    const endpoint = this.config.visitorEndpoint || `${this.config.endpoint}/api/visitors`;
-    const previousVisitorId = this.getCookieVisitorId() || this.cachedVisitor?.result.visitorId || void 0;
+  async captureFingerprint(screenName) {
+    if (!this.active || this.rasterInFlight || !this.rasterizer) return;
+    this.rasterInFlight = true;
     try {
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-Key": this.config.apiKey
-        },
-        credentials: "include",
-        body: JSON.stringify({
-          signals,
-          stableFingerprint,
-          previousVisitorId
-        })
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
+      const raster = await this.rasterizer.rasterize();
+      if (!raster) {
+        if (!this.fpCache.has(screenName)) {
+          this.fpCache.set(screenName, screenFingerprint(screenName, ZERO_HASH));
+        }
+        return;
       }
-      const result = await response.json();
-      this.cachedVisitor = {
-        result,
-        signals,
-        cachedAt: Date.now()
-      };
-      this.saveToStorage();
-      this.setCookieVisitorId(result.visitorId);
-      this.log("Visitor ID fetched:", result.visitorId);
-      return result;
+      const hash = dHash(raster.rgba, raster.width, raster.height);
+      const fp = screenFingerprint(screenName, hash);
+      this.fpCache.set(screenName, fp);
+      await this.maybeUploadTemplate(screenName, hash, fp, raster);
     } catch (err) {
-      this.log("Failed to fetch visitor ID:", err);
-      throw err;
+      this.log("Fingerprint capture failed:", err);
+      if (!this.fpCache.has(screenName)) {
+        this.fpCache.set(screenName, screenFingerprint(screenName, ZERO_HASH));
+      }
+    } finally {
+      this.rasterInFlight = false;
     }
   }
-  calculateRiskScore(signals, vpnDetected = false) {
-    let score = 0;
-    const smart = signals.smart;
-    if (smart?.bot || signals.bot) score += 0.8;
-    if (signals.behavior) {
-      if (signals.behavior.score < 0.3) score += 0.4;
-      else if (signals.behavior.score < 0.5) score += 0.2;
+  async maybeUploadTemplate(screenName, hash, fp, raster) {
+    for (const uploaded of this.uploadedFps) {
+      const parsed = parseFingerprint(uploaded);
+      if (parsed.screenName === screenName && hamming(parsed.pHashHex, hash) <= HAMMING_THRESHOLD) {
+        return;
+      }
     }
-    if (vpnDetected) score += 0.25;
-    if (smart?.incognito || signals.incognito) score += 0.2;
-    if (smart?.devToolsOpen) score += 0.1;
-    if (smart?.privacyBrowser) score += 0.1;
-    if (signals.hardwareConcurrency === 0) score += 0.1;
-    if (signals.maxTouchPoints === 0 && /mobile|android|iphone/i.test(signals.userAgent)) {
-      score += 0.15;
+    if (!raster.pngBase64) return;
+    try {
+      const res = await this.transport(
+        `${this.config.endpoint}/api/taps/template`,
+        JSON.stringify({
+          route_name: screenName,
+          p_hash: hash,
+          width: raster.width,
+          height: raster.height,
+          image_base64: raster.pngBase64
+        }),
+        { headers: this.headers() }
+      );
+      if (res.ok) {
+        this.uploadedFps.add(fp);
+        this.log("Uploaded template for", fp);
+      }
+    } catch (err) {
+      this.log("Template upload failed:", err);
     }
-    if (!signals.cookieEnabled) score += 0.1;
-    if (smart?.doNotTrack) score += 0.05;
-    if (smart?.deviceVisitCount === 1) score += 0.05;
-    return Math.round(Math.min(score, 1) * 100) / 100;
   }
-  isCacheExpired() {
-    if (!this.cachedVisitor) return true;
-    return Date.now() - this.cachedVisitor.cachedAt > CACHE_TTL_MS;
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
+  combinedBlockSelector() {
+    return this.config.blockSelector ? `${DEFAULT_BLOCK_SELECTOR}, ${this.config.blockSelector}` : DEFAULT_BLOCK_SELECTOR;
   }
-  loadFromStorage() {
-    if (typeof window === "undefined" || typeof localStorage === "undefined") return;
-    try {
-      const stored = localStorage.getItem(CACHE_KEY);
-      if (!stored) return;
-      const parsed = JSON.parse(stored);
-      if (!this.isCacheExpiredAt(parsed.cachedAt)) {
-        this.cachedVisitor = parsed;
-        this.log("Loaded cached visitor from storage");
-      } else {
-        localStorage.removeItem(CACHE_KEY);
-      }
-    } catch {
+  pathname() {
+    if (typeof window === "undefined" || !window.location) return null;
+    return window.location.pathname || "/";
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong Watchtower]", ...args);
     }
   }
-  saveToStorage() {
-    if (typeof window === "undefined" || typeof localStorage === "undefined") return;
-    if (!this.cachedVisitor) return;
-    try {
-      localStorage.setItem(CACHE_KEY, JSON.stringify(this.cachedVisitor));
-    } catch {
+};
+function clamp01(n) {
+  if (!Number.isFinite(n)) return 0;
+  return Math.min(1, Math.max(0, n));
+}
+function roleForTag(tag) {
+  switch (tag) {
+    case "a":
+      return "link";
+    case "button":
+      return "button";
+    case "input":
+      return "input";
+    case "select":
+      return "select";
+    case "textarea":
+      return "textarea";
+    default:
+      return tag || void 0;
+  }
+}
+function idle(cb) {
+  const g = globalThis;
+  if (typeof g.requestIdleCallback === "function") {
+    g.requestIdleCallback(cb, { timeout: 2e3 });
+  } else {
+    setTimeout(cb, 250);
+  }
+}
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function stripInvalidXml(text) {
+  return text.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g, "");
+}
+function serializedToXhtml(node, isRoot = false) {
+  if (node.type === "text") {
+    return escapeXml(stripInvalidXml(node.textContent ?? ""));
+  }
+  if (node.type === "comment") {
+    return "";
+  }
+  const tagName = (node.tagName || "div").toLowerCase();
+  const attrs = { ...node.attributes || {} };
+  const cssText = attrs["_cssText"];
+  if (tagName === "style" || tagName === "link") {
+    if (typeof cssText === "string" && cssText) {
+      return `<style>${escapeXml(stripInvalidXml(cssText))}</style>`;
     }
+    if (tagName === "link") return "";
   }
-  isCacheExpiredAt(cachedAt) {
-    return Date.now() - cachedAt > CACHE_TTL_MS;
+  const computedStyle = attrs["_computedStyle"];
+  if (typeof computedStyle === "string" && computedStyle) {
+    attrs["style"] = attrs["style"] ? `${attrs["style"]};${computedStyle}` : computedStyle;
   }
-  getCookieVisitorId() {
-    if (typeof document === "undefined") return void 0;
-    try {
-      const match = document.cookie.match(new RegExp(`(?:^|; )${COOKIE_NAME}=([^;]*)`));
-      return match?.[1] || void 0;
-    } catch {
-      return void 0;
+  const value = attrs["_value"];
+  if (typeof value === "string" && value) {
+    attrs["value"] = value;
+  }
+  if (attrs["_checked"] === "true") {
+    attrs["checked"] = "checked";
+  }
+  let attrString = "";
+  for (const [name, val] of Object.entries(attrs)) {
+    if (name.startsWith("_")) continue;
+    if (name.startsWith("on")) continue;
+    if (!/^[a-zA-Z_][\w:.-]*$/.test(name)) continue;
+    attrString += ` ${name}="${escapeXml(stripInvalidXml(String(val)))}"`;
+  }
+  if (isRoot) {
+    attrString = ` xmlns="http://www.w3.org/1999/xhtml"${attrString}`;
+  }
+  if (VOID_TAGS.has(tagName)) {
+    return `<${tagName}${attrString}/>`;
+  }
+  let childHtml = "";
+  if (tagName === "style" && typeof cssText !== "string") {
+    for (const child of node.children || []) {
+      childHtml += serializedToXhtml(child);
+    }
+  } else {
+    for (const child of node.children || []) {
+      childHtml += serializedToXhtml(child);
     }
   }
-  setCookieVisitorId(visitorId) {
-    if (typeof document === "undefined") return;
+  return `<${tagName}${attrString}>${childHtml}</${tagName}>`;
+}
+var DomRasterizer = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async rasterize() {
     try {
-      document.cookie = `${COOKIE_NAME}=${visitorId}; path=/; max-age=${COOKIE_MAX_AGE}; SameSite=Lax`;
+      if (typeof document === "undefined" || typeof window === "undefined") return null;
+      resetNodeIds();
+      const tree = serializeNode(document.documentElement, {
+        maskInputs: true,
+        blockSelector: this.options.blockSelector,
+        maskSelector: this.options.maskSelector
+      });
+      if (!tree) return null;
+      const vw = window.innerWidth || 1;
+      const vh = window.innerHeight || 1;
+      const xhtml = serializedToXhtml(tree, true);
+      const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${vw}" height="${vh}"><foreignObject width="100%" height="100%">${xhtml}</foreignObject></svg>`;
+      const img = await loadSvgImage(svg);
+      const scale = Math.min(1, (this.options.maxWidth ?? RASTER_MAX_WIDTH) / vw);
+      const w = Math.max(1, Math.round(vw * scale));
+      const h = Math.max(1, Math.round(vh * scale));
+      const canvas = document.createElement("canvas");
+      canvas.width = w;
+      canvas.height = h;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return null;
+      ctx.fillStyle = "#ffffff";
+      ctx.fillRect(0, 0, w, h);
+      ctx.drawImage(img, 0, 0, w, h);
+      const imageData = ctx.getImageData(0, 0, w, h);
+      const rgba = new Uint8Array(imageData.data.buffer, imageData.data.byteOffset, imageData.data.byteLength);
+      let pngBase64 = null;
+      try {
+        const dataUrl = canvas.toDataURL("image/png");
+        const prefix = "data:image/png;base64,";
+        pngBase64 = dataUrl.startsWith(prefix) ? dataUrl.slice(prefix.length) : null;
+      } catch {
+        pngBase64 = null;
+      }
+      return { rgba, width: w, height: h, pngBase64 };
     } catch {
-    }
-  }
-  log(...args) {
-    if (this.config.debug) {
-      console.log("[SitePong Fingerprint]", ...args);
+      return null;
     }
   }
 };
+function loadSvgImage(svg) {
+  return new Promise((resolve, reject) => {
+    const blob = new Blob([svg], { type: "image/svg+xml;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const img = new Image();
+    const timer = setTimeout(() => {
+      URL.revokeObjectURL(url);
+      reject(new Error("SVG rasterization timed out"));
+    }, 3e3);
+    img.onload = () => {
+      clearTimeout(timer);
+      URL.revokeObjectURL(url);
+      resolve(img);
+    };
+    img.onerror = () => {
+      clearTimeout(timer);
+      URL.revokeObjectURL(url);
+      reject(new Error("SVG rasterization failed"));
+    };
+    img.src = url;
+  });
+}
 
 // src/entries/web.ts
 setEnvironment(createWebEnvironment());
 registerWebManagerFactories({
   createReplay: (cfg) => new ReplayManager(cfg),
   createFingerprint: (cfg) => new FingerprintManager(cfg),
-  createPerformance: (cfg) => new PerformanceManager(cfg)
+  createPerformance: (cfg) => new PerformanceManager(cfg),
+  createWatchtowerCapture: (cfg) => new WatchtowerWebCapture(cfg)
 });
 
-export { DEFAULT_SUPERLINK_ENDPOINT, SuperLinkClient, TracePropagator, addBreadcrumb, areFlagsReady, captureError, captureMessage, captureWebDeepLink, clearAnonymousId, clearUser, sitepong as client, completeFromScan, createTraceContext, cronCheckin, cronStart, cronWrap, dbTrack, dbTrackSync, src_default as default, endSpan, endTransaction, extractIdentityMetadata, extractTrace, flush, flushMetrics, flushProfiles, generateSpanId, generateTraceId, getAllFlags, getAnonymousId, getDbNPlusOnePatterns, getDbQueryCount, getDeepLink, getDeviceSignals, getFlag, getFraudCheck, getLatestProfile, getMatchedDeepLink, getProfiles, getRemoteConfig, getReplaySessionId, getVariant, getVariantPayload2 as getVariantPayload, getVisitorId, getWebVitals, group, identify2 as identify, init, initRN, initSuperLink, isInitialized, isRemoteConfigFeatureEnabled, isReplayRecording, metricDistribution, metricGauge, metricHistogram, metricIncrement, metricStartTimer, metricTime, onDeferredDeepLink, onRemoteConfigChange, parseUniversalLink, profile, propagateTrace, refreshFlags, registerIdentifyHook, registerWebManagerFactories, resetAnalytics, resetDbQueryCount, setAnonymousId, setContext, setCurrentScreen, setEnvironment, setRNGetCurrentScreen, setTags, setUser, startProfileSpan, startReplay, startSpan, startTransaction, stopReplay, superlinkClient, identify as superlinkIdentify, track, trackPageView, waitForFlags, writeClipboardToken };
+export { DEFAULT_SUPERLINK_ENDPOINT, SuperLinkClient, TracePropagator, addBreadcrumb, areFlagsReady, captureError, captureMessage, captureWebDeepLink, clearAnonymousId, clearUser, sitepong as client, completeFromScan, createTraceContext, cronCheckin, cronStart, cronWrap, dbTrack, dbTrackSync, src_default as default, endSpan, endTransaction, extractIdentityMetadata, extractTrace, flush, flushMetrics, flushProfiles, generateSpanId, generateTraceId, getAllFlags, getAnonymousId, getDbNPlusOnePatterns, getDbQueryCount, getDeepLink, getDeviceSignals, getFlag, getFraudCheck, getLatestProfile, getMatchedDeepLink, getProfiles, getRemoteConfig, getReplaySessionId, getVariant, getVariantPayload2 as getVariantPayload, getVisitorId, getWebVitals, group, identify2 as identify, init, initRN, initSuperLink, isInitialized, isRemoteConfigFeatureEnabled, isReplayRecording, metricDistribution, metricGauge, metricHistogram, metricIncrement, metricStartTimer, metricTime, onDeferredDeepLink, onRemoteConfigChange, parseUniversalLink, profile, propagateTrace, refreshFlags, registerIdentifyHook, registerWebManagerFactories, resetAnalytics, resetDbQueryCount, setAnonymousId, setContext, setCurrentScreen, setEnvironment, setRNGetCurrentScreen, setTags, setUser, startProfileSpan, startReplay, startSpan, startTransaction, startWatchtowerCapture, stopReplay, stopWatchtowerCapture, superlinkClient, identify as superlinkIdentify, track, trackPageView, waitForFlags, writeClipboardToken };
 //# sourceMappingURL=web.mjs.map
 //# sourceMappingURL=web.mjs.map