sitepong 0.2.1 → 0.2.3

package/dist/entries/web.js

@@ -688,6 +688,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;
@@ -702,6 +703,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;
@@ -734,7 +756,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
@@ -756,7 +778,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
@@ -973,6 +995,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 });
@@ -1924,646 +1954,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() {
-    webVitals.onCLS((m) => {
-      this.vitals.cls = m.value;
-      this.reportVital("CLS", m.value, "score");
-    });
-    webVitals.onINP((m) => {
-      this.vitals.inp = m.value;
-      this.reportVital("INP", m.value);
-    });
-    webVitals.onLCP((m) => {
-      this.vitals.lcp = m.value;
-      this.reportVital("LCP", m.value);
-    });
-    webVitals.onTTFB((m) => {
-      this.vitals.ttfb = m.value;
-      this.reportVital("TTFB", m.value);
-    });
-    webVitals.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;
     }
   }
 };
@@ -2961,10 +2492,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 = [];
@@ -2983,16 +2514,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
     };
   }
@@ -3014,7 +2547,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) => {
@@ -3027,7 +2560,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,
@@ -3043,7 +2576,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,
@@ -3058,7 +2591,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,
@@ -3082,7 +2615,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,
@@ -3102,17 +2635,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
@@ -3121,7 +2660,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
@@ -3130,7 +2669,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,
@@ -3141,7 +2680,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
       });
@@ -3175,7 +2714,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) => {
@@ -3188,7 +2727,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,
@@ -3200,14 +2739,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
@@ -3216,7 +2755,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
@@ -3225,7 +2764,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,
@@ -3236,7 +2775,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
       });
@@ -3341,6 +2880,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;
@@ -3408,13 +2948,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;
@@ -3559,6 +3142,7 @@ var SitePongClient = class {
     if (this.replayManager) {
       this.replayManager.setUser(null);
     }
+    this.watchtowerCapture?.setDistinctId(null);
   }
   addBreadcrumb(breadcrumb) {
     this.log("Breadcrumb added:", breadcrumb);
@@ -3628,15 +3212,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) {
@@ -3783,6 +3367,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);
@@ -4499,10 +4085,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) {
@@ -4529,7 +4115,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,
@@ -4665,14 +4251,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);
     }
   }
   /**
@@ -5967,542 +5553,1757 @@ 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() {
+    webVitals.onCLS((m) => {
+      this.vitals.cls = m.value;
+      this.reportVital("CLS", m.value, "score");
+    });
+    webVitals.onINP((m) => {
+      this.vitals.inp = m.value;
+      this.reportVital("INP", m.value);
+    });
+    webVitals.onLCP((m) => {
+      this.vitals.lcp = m.value;
+      this.reportVital("LCP", m.value);
+    });
+    webVitals.onTTFB((m) => {
+      this.vitals.ttfb = m.value;
+      this.reportVital("TTFB", m.value);
+    });
+    webVitals.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)
 });
 
 exports.DEFAULT_SUPERLINK_ENDPOINT = DEFAULT_SUPERLINK_ENDPOINT;
@@ -6585,7 +7386,9 @@ exports.startProfileSpan = startProfileSpan;
 exports.startReplay = startReplay;
 exports.startSpan = startSpan;
 exports.startTransaction = startTransaction;
+exports.startWatchtowerCapture = startWatchtowerCapture;
 exports.stopReplay = stopReplay;
+exports.stopWatchtowerCapture = stopWatchtowerCapture;
 exports.superlinkClient = superlinkClient;
 exports.superlinkIdentify = identify;
 exports.track = track;