sitepong 0.0.1 → 0.0.5

package/dist/index.mjs

@@ -1,21 +1,4043 @@
+// src/flags/anonymous-id.ts
+var STORAGE_KEY = "sitepong_anonymous_id";
+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);
+  });
+}
+var memoryId = null;
+function getAnonymousId() {
+  if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+    try {
+      let id = localStorage.getItem(STORAGE_KEY);
+      if (!id) {
+        id = generateUUID();
+        localStorage.setItem(STORAGE_KEY, id);
+      }
+      return id;
+    } catch {
+      if (!memoryId) {
+        memoryId = generateUUID();
+      }
+      return memoryId;
+    }
+  }
+  if (!memoryId) {
+    memoryId = generateUUID();
+  }
+  return memoryId;
+}
+function clearAnonymousId() {
+  if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+    try {
+      localStorage.removeItem(STORAGE_KEY);
+    } catch {
+    }
+  }
+  memoryId = null;
+}
+function setAnonymousId(id) {
+  if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+    try {
+      localStorage.setItem(STORAGE_KEY, id);
+    } catch {
+      memoryId = id;
+    }
+  } else {
+    memoryId = id;
+  }
+}
+
+// src/flags/context.ts
+function detectDeviceType(userAgent) {
+  const ua = userAgent.toLowerCase();
+  if (/ipad/.test(ua) || /android/.test(ua) && !/mobile/.test(ua) || /tablet/.test(ua)) {
+    return "tablet";
+  }
+  if (/mobile/.test(ua) || /iphone/.test(ua) || /ipod/.test(ua) || /android/.test(ua) || /blackberry/.test(ua) || /windows phone/.test(ua)) {
+    return "mobile";
+  }
+  return "desktop";
+}
+function detectBrowser(userAgent) {
+  const ua = userAgent.toLowerCase();
+  if (/edg/.test(ua)) return "edge";
+  if (/opr|opera/.test(ua)) return "opera";
+  if (/samsungbrowser/.test(ua)) return "samsung";
+  if (/chrome|chromium|crios/.test(ua)) return "chrome";
+  if (/safari/.test(ua) && !/chrome/.test(ua)) return "safari";
+  if (/firefox|fxios/.test(ua)) return "firefox";
+  if (/msie|trident/.test(ua)) return "ie";
+  return "other";
+}
+function detectOS(userAgent) {
+  const ua = userAgent.toLowerCase();
+  if (/iphone|ipad|ipod/.test(ua)) return "ios";
+  if (/android/.test(ua)) return "android";
+  if (/mac os|macos|macintosh/.test(ua)) return "macos";
+  if (/windows/.test(ua)) return "windows";
+  if (/linux/.test(ua)) return "linux";
+  return "other";
+}
+function getEvaluationContext() {
+  const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
+  return {
+    anonymous_id: getAnonymousId(),
+    device_type: userAgent ? detectDeviceType(userAgent) : void 0,
+    browser: userAgent ? detectBrowser(userAgent) : void 0,
+    os: userAgent ? detectOS(userAgent) : void 0,
+    user_agent: userAgent || void 0,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+
+// src/flags/evaluator.ts
+function djb2Hash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash ^ str.charCodeAt(i);
+  }
+  return hash >>> 0;
+}
+function evaluatePercentageRollout(config) {
+  return Math.random() * 100 < config.percentage;
+}
+function evaluateUserbasePercentage(config, context, flagKey) {
+  const hashInput = `${context.anonymous_id}:${flagKey}`;
+  const hash = djb2Hash(hashInput);
+  const bucket = hash % 100;
+  return bucket < config.percentage;
+}
+function parseTime(timeStr) {
+  const [hours, minutes] = timeStr.split(":").map(Number);
+  return hours * 60 + minutes;
+}
+function evaluateTimeBased(config, context) {
+  const now = context.timestamp || /* @__PURE__ */ new Date();
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: config.timezone,
+    weekday: "short",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const parts = formatter.formatToParts(now);
+  const dayOfWeek = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(
+    parts.find((p) => p.type === "weekday")?.value || ""
+  );
+  const hour = parseInt(parts.find((p) => p.type === "hour")?.value || "0", 10);
+  const minute = parseInt(parts.find((p) => p.type === "minute")?.value || "0", 10);
+  const currentMinutes = hour * 60 + minute;
+  if (config.days_of_week && config.days_of_week.length > 0) {
+    if (!config.days_of_week.includes(dayOfWeek)) {
+      return false;
+    }
+  }
+  if (config.start_time && config.end_time) {
+    const startMinutes = parseTime(config.start_time);
+    const endMinutes = parseTime(config.end_time);
+    if (startMinutes > endMinutes) {
+      if (currentMinutes < startMinutes && currentMinutes >= endMinutes) {
+        return false;
+      }
+    } else {
+      if (currentMinutes < startMinutes || currentMinutes >= endMinutes) {
+        return false;
+      }
+    }
+  } else if (config.start_time) {
+    const startMinutes = parseTime(config.start_time);
+    if (currentMinutes < startMinutes) {
+      return false;
+    }
+  } else if (config.end_time) {
+    const endMinutes = parseTime(config.end_time);
+    if (currentMinutes >= endMinutes) {
+      return false;
+    }
+  }
+  return true;
+}
+function evaluateDeviceType(config, context) {
+  if (!context.device_type) {
+    return false;
+  }
+  return config.types.includes(context.device_type);
+}
+function evaluateBrowser(config, context) {
+  if (!context.browser) {
+    return false;
+  }
+  return config.browsers.includes(context.browser);
+}
+function evaluateOS(config, context) {
+  if (!context.os) {
+    return false;
+  }
+  return config.operating_systems.includes(context.os);
+}
+function evaluateRule(ruleType, config, context, flagKey) {
+  switch (ruleType) {
+    case "percentage_rollout":
+      return evaluatePercentageRollout(config);
+    case "userbase_percentage":
+      return evaluateUserbasePercentage(
+        config,
+        context,
+        flagKey
+      );
+    case "time_based":
+      return evaluateTimeBased(config, context);
+    case "device_type":
+      return evaluateDeviceType(config, context);
+    case "browser":
+      return evaluateBrowser(config, context);
+    case "os":
+      return evaluateOS(config, context);
+    default:
+      return false;
+  }
+}
+function evaluateFlag(flag, context) {
+  if (flag.override === "force_on") {
+    return true;
+  }
+  if (flag.override === "force_off") {
+    return false;
+  }
+  if (!flag.enabled) {
+    return false;
+  }
+  if (!flag.rules || flag.rules.length === 0) {
+    return true;
+  }
+  for (const rule of flag.rules) {
+    const result = evaluateRule(rule.rule_type, rule.config, context, flag.key);
+    if (!result) {
+      return false;
+    }
+  }
+  return true;
+}
+function evaluateVariant(flag, context) {
+  if (!evaluateFlag(flag, context)) {
+    return null;
+  }
+  if (flag.flag_type !== "multivariate" || !flag.variants || flag.variants.length === 0) {
+    return null;
+  }
+  const hashInput = `${context.anonymous_id}:${flag.key}:variant`;
+  const hash = djb2Hash(hashInput);
+  const totalWeight = flag.variants.reduce((sum, v) => sum + v.weight, 0);
+  const bucket = hash % totalWeight;
+  let cumulative = 0;
+  for (const variant of flag.variants) {
+    cumulative += variant.weight;
+    if (bucket < cumulative) {
+      return variant.key;
+    }
+  }
+  return flag.variants[0].key;
+}
+function getVariantPayload(flag, variantKey) {
+  if (flag.variant_payloads && flag.variant_payloads[variantKey] !== void 0) {
+    return flag.variant_payloads[variantKey];
+  }
+  const variant = flag.variants?.find((v) => v.key === variantKey);
+  return variant?.payload || null;
+}
+
+// src/flags/manager.ts
+var DEFAULT_ENDPOINT = "https://api.sitepong.com";
+var FlagManager = class {
+  constructor(config) {
+    this.flags = /* @__PURE__ */ new Map();
+    this.evaluatedFlags = /* @__PURE__ */ new Map();
+    this.evaluatedVariants = /* @__PURE__ */ new Map();
+    this.context = null;
+    this.initialized = false;
+    this.initPromise = null;
+    this.config = {
+      endpoint: DEFAULT_ENDPOINT,
+      debug: false,
+      ...config
+    };
+  }
+  /**
+   * Initialize the flag manager by fetching flags
+   * Flags are evaluated once on init and cached
+   */
+  async init() {
+    if (this.initialized) {
+      return;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.fetchAndEvaluateFlags();
+    try {
+      await this.initPromise;
+      this.initialized = true;
+    } catch (err) {
+      this.log("Failed to initialize flags:", err);
+      this.initialized = true;
+    } finally {
+      this.initPromise = null;
+    }
+  }
+  /**
+   * Fetch flags from the API and evaluate them
+   */
+  async fetchAndEvaluateFlags() {
+    try {
+      const response = await fetch(`${this.config.endpoint}/api/sdk/flags`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      this.log("Fetched flags:", data.flags.length);
+      this.context = getEvaluationContext();
+      this.log("Evaluation context:", this.context);
+      this.flags.clear();
+      this.evaluatedFlags.clear();
+      this.evaluatedVariants.clear();
+      for (const flag of data.flags) {
+        this.flags.set(flag.key, flag);
+        const result = evaluateFlag(flag, this.context);
+        this.evaluatedFlags.set(flag.key, result);
+        if (flag.flag_type === "multivariate" && flag.variants) {
+          const variant = evaluateVariant(flag, this.context);
+          this.evaluatedVariants.set(flag.key, variant);
+          this.log(`Flag "${flag.key}": ${result}, variant: ${variant}`);
+        } else {
+          this.log(`Flag "${flag.key}": ${result}`);
+        }
+      }
+    } catch (err) {
+      this.log("Error fetching flags:", err);
+      throw err;
+    }
+  }
+  /**
+   * Get a flag value
+   * Returns the cached evaluated result or default value
+   */
+  getFlag(key, defaultValue = false) {
+    if (!this.initialized) {
+      this.log(`Flag "${key}" requested before init, returning default:`, defaultValue);
+      return defaultValue;
+    }
+    const value = this.evaluatedFlags.get(key);
+    if (value === void 0) {
+      this.log(`Flag "${key}" not found, returning default:`, defaultValue);
+      return defaultValue;
+    }
+    return value;
+  }
+  /**
+   * Get a multivariate flag variant
+   * Returns the assigned variant key or the default value
+   */
+  getVariant(key, defaultValue = null) {
+    if (!this.initialized) {
+      this.log(`Variant "${key}" requested before init, returning default:`, defaultValue);
+      return defaultValue;
+    }
+    const variant = this.evaluatedVariants.get(key);
+    if (variant === void 0) {
+      this.log(`Variant "${key}" not found, returning default:`, defaultValue);
+      return defaultValue;
+    }
+    return variant;
+  }
+  /**
+   * Get the payload for a multivariate flag's assigned variant
+   */
+  getVariantPayload(key, defaultValue = null) {
+    const variant = this.getVariant(key);
+    if (!variant) return defaultValue;
+    const flag = this.flags.get(key);
+    if (!flag) return defaultValue;
+    const payload = getVariantPayload(flag, variant);
+    return payload ?? defaultValue;
+  }
+  /**
+   * Get all flag values
+   */
+  getAllFlags() {
+    const result = {};
+    for (const [key, value] of this.evaluatedFlags) {
+      result[key] = value;
+    }
+    return result;
+  }
+  /**
+   * Check if a flag exists
+   */
+  hasFlag(key) {
+    return this.flags.has(key);
+  }
+  /**
+   * Check if flags are initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Wait for initialization to complete
+   */
+  async waitForInit() {
+    if (this.initialized) {
+      return;
+    }
+    await this.init();
+  }
+  /**
+   * Force re-fetch and re-evaluate flags
+   * Call this if you need to refresh flags (e.g., on explicit user action)
+   */
+  async refresh() {
+    this.initialized = false;
+    await this.init();
+  }
+  /**
+   * Get the current evaluation context
+   */
+  getContext() {
+    return this.context;
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong Flags]", ...args);
+    }
+  }
+};
+
+// src/analytics/session.ts
+var SESSION_KEY = "sitepong_session_id";
+var SESSION_TIMESTAMP_KEY = "sitepong_session_ts";
+var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var memorySessionId = null;
+var memorySessionTs = null;
+function generateSessionId() {
+  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);
+  });
+}
+function isSessionExpired(lastActivity) {
+  return Date.now() - lastActivity > SESSION_TIMEOUT_MS;
+}
+function getSessionId() {
+  if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
+    try {
+      const existingId = sessionStorage.getItem(SESSION_KEY);
+      const lastTs = sessionStorage.getItem(SESSION_TIMESTAMP_KEY);
+      if (existingId && lastTs && !isSessionExpired(parseInt(lastTs, 10))) {
+        sessionStorage.setItem(SESSION_TIMESTAMP_KEY, String(Date.now()));
+        return existingId;
+      }
+      const newId = generateSessionId();
+      sessionStorage.setItem(SESSION_KEY, newId);
+      sessionStorage.setItem(SESSION_TIMESTAMP_KEY, String(Date.now()));
+      return newId;
+    } catch {
+      return getMemorySession();
+    }
+  }
+  return getMemorySession();
+}
+function getMemorySession() {
+  if (memorySessionId && memorySessionTs && !isSessionExpired(memorySessionTs)) {
+    memorySessionTs = Date.now();
+    return memorySessionId;
+  }
+  memorySessionId = generateSessionId();
+  memorySessionTs = Date.now();
+  return memorySessionId;
+}
+function clearSession() {
+  if (typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
+    try {
+      sessionStorage.removeItem(SESSION_KEY);
+      sessionStorage.removeItem(SESSION_TIMESTAMP_KEY);
+    } catch {
+    }
+  }
+  memorySessionId = null;
+  memorySessionTs = null;
+}
+
+// src/analytics/autocapture.ts
+var DEFAULT_BLOCK_SELECTORS = [
+  "[data-sp-no-capture]",
+  ".sp-no-capture"
+];
+var MAX_TEXT_LENGTH = 255;
+var AutocaptureModule = class {
+  constructor(config, callback) {
+    this.clickHandler = null;
+    this.submitHandler = null;
+    this.active = false;
+    this.config = {
+      clicks: true,
+      forms: true,
+      pageviews: true,
+      blockSelectors: DEFAULT_BLOCK_SELECTORS,
+      maxTextLength: MAX_TEXT_LENGTH,
+      debug: false,
+      ...config
+    };
+    this.callback = callback;
+  }
+  start() {
+    if (this.active || typeof window === "undefined") return;
+    this.active = true;
+    if (this.config.clicks) {
+      this.setupClickCapture();
+    }
+    if (this.config.forms) {
+      this.setupFormCapture();
+    }
+    this.log("Autocapture started");
+  }
+  stop() {
+    if (!this.active) return;
+    this.active = false;
+    if (this.clickHandler) {
+      document.removeEventListener("click", this.clickHandler, true);
+      this.clickHandler = null;
+    }
+    if (this.submitHandler) {
+      document.removeEventListener("submit", this.submitHandler, true);
+      this.submitHandler = null;
+    }
+    this.log("Autocapture stopped");
+  }
+  setupClickCapture() {
+    this.clickHandler = (e) => {
+      const target = e.target;
+      if (!target || !this.shouldCapture(target)) return;
+      const properties = this.getElementProperties(target);
+      properties.$event_type = "click";
+      properties.$x = e.clientX;
+      properties.$y = e.clientY;
+      this.callback({
+        type: "click",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        properties
+      });
+    };
+    document.addEventListener("click", this.clickHandler, true);
+  }
+  setupFormCapture() {
+    this.submitHandler = (e) => {
+      const form = e.target;
+      if (!form || !this.shouldCapture(form)) return;
+      const properties = {
+        $event_type: "form_submit",
+        $form_action: form.action || void 0,
+        $form_method: form.method || "get",
+        $form_name: form.name || form.id || void 0,
+        $field_names: this.getFormFieldNames(form),
+        $field_count: form.elements.length
+      };
+      const elemProps = this.getElementProperties(form);
+      Object.assign(properties, elemProps);
+      this.callback({
+        type: "form_submit",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        properties
+      });
+    };
+    document.addEventListener("submit", this.submitHandler, true);
+  }
+  shouldCapture(element) {
+    const blockSelectors = this.config.blockSelectors || DEFAULT_BLOCK_SELECTORS;
+    for (const selector of blockSelectors) {
+      if (element.matches(selector) || element.closest(selector)) {
+        return false;
+      }
+    }
+    if (this.config.allowSelectors && this.config.allowSelectors.length > 0) {
+      const matches = this.config.allowSelectors.some(
+        (sel) => element.matches(sel) || element.closest(sel) !== null
+      );
+      if (!matches) return false;
+    }
+    if (element.offsetParent === null && element.tagName !== "BODY") {
+      return false;
+    }
+    return true;
+  }
+  getElementProperties(element) {
+    const properties = {};
+    properties.$tag_name = element.tagName.toLowerCase();
+    properties.$el_id = element.id || void 0;
+    if (element.classList.length > 0) {
+      properties.$el_classes = Array.from(element.classList).slice(0, 5);
+    }
+    const text = this.getElementText(element);
+    if (text) {
+      properties.$el_text = text;
+    }
+    if (element instanceof HTMLAnchorElement) {
+      properties.$href = element.href || void 0;
+      properties.$target = element.target || void 0;
+    }
+    if (element instanceof HTMLInputElement || element instanceof HTMLButtonElement) {
+      properties.$el_type = element.type || void 0;
+      properties.$el_name = element.name || void 0;
+    }
+    const ariaLabel = element.getAttribute("aria-label");
+    if (ariaLabel) {
+      properties.$aria_label = this.truncate(ariaLabel);
+    }
+    const role = element.getAttribute("role");
+    if (role) {
+      properties.$el_role = role;
+    }
+    properties.$selector = this.getSelector(element);
+    properties.$current_url = window.location.href;
+    properties.$pathname = window.location.pathname;
+    return properties;
+  }
+  getElementText(element) {
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+      return void 0;
+    }
+    let text = "";
+    if (element instanceof HTMLButtonElement || element instanceof HTMLAnchorElement) {
+      text = element.innerText || element.textContent || "";
+    } else {
+      for (const node of Array.from(element.childNodes)) {
+        if (node.nodeType === Node.TEXT_NODE) {
+          text += node.textContent || "";
+        }
+      }
+    }
+    text = text.trim().replace(/\s+/g, " ");
+    return text ? this.truncate(text) : void 0;
+  }
+  getFormFieldNames(form) {
+    const names = [];
+    for (const element of Array.from(form.elements)) {
+      const input = element;
+      if (input.name && input.type !== "password" && input.type !== "hidden") {
+        names.push(input.name);
+      }
+    }
+    return names.slice(0, 20);
+  }
+  getSelector(element) {
+    const parts = [];
+    let current = element;
+    let depth = 0;
+    while (current && current !== document.body && depth < 5) {
+      let selector = current.tagName.toLowerCase();
+      if (current.id) {
+        selector = `#${current.id}`;
+        parts.unshift(selector);
+        break;
+      }
+      if (current.classList.length > 0) {
+        selector += `.${Array.from(current.classList).slice(0, 2).join(".")}`;
+      }
+      const parent = current.parentElement;
+      if (parent) {
+        const siblings = Array.from(parent.children).filter(
+          (c) => c.tagName === current.tagName
+        );
+        if (siblings.length > 1) {
+          const index = siblings.indexOf(current) + 1;
+          selector += `:nth-of-type(${index})`;
+        }
+      }
+      parts.unshift(selector);
+      current = current.parentElement;
+      depth++;
+    }
+    return parts.join(" > ");
+  }
+  truncate(text) {
+    const max = this.config.maxTextLength || MAX_TEXT_LENGTH;
+    return text.length > max ? text.slice(0, max) + "..." : text;
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong Autocapture]", ...args);
+    }
+  }
+};
+
+// src/analytics/manager.ts
+var DEFAULT_ENDPOINT2 = "https://ingest.sitepong.com";
+var DEFAULT_BATCH_SIZE = 20;
+var DEFAULT_FLUSH_INTERVAL = 1e4;
+var AnalyticsManager = class {
+  constructor(config) {
+    this.eventQueue = [];
+    this.flushTimer = null;
+    this.userId = null;
+    this.groupId = null;
+    this.userTraits = null;
+    this.groupTraits = null;
+    this.lastUrl = null;
+    this.popstateHandler = null;
+    this.autocaptureModule = null;
+    this.config = {
+      endpoint: DEFAULT_ENDPOINT2,
+      enabled: true,
+      autocapturePageviews: false,
+      maxBatchSize: DEFAULT_BATCH_SIZE,
+      flushInterval: DEFAULT_FLUSH_INTERVAL,
+      debug: false,
+      ...config
+    };
+  }
+  init() {
+    if (!this.config.enabled) {
+      return;
+    }
+    this.startFlushTimer();
+    this.setupPageHideListener();
+    if (this.config.autocapturePageviews) {
+      this.setupSPATracking();
+    }
+    this.setupAutocapture();
+    this.log("Analytics initialized");
+  }
+  setupAutocapture() {
+    const ac = this.config.autocapture;
+    const clicksEnabled = this.config.autocaptureClicks;
+    const formsEnabled = this.config.autocaptureForms;
+    let captureClicks = clicksEnabled || false;
+    let captureForms = formsEnabled || false;
+    let blockSelectors;
+    let allowSelectors;
+    if (ac === true) {
+      captureClicks = true;
+      captureForms = true;
+    } else if (ac && typeof ac === "object") {
+      captureClicks = ac.clicks !== false;
+      captureForms = ac.forms !== false;
+      blockSelectors = ac.blockSelectors;
+      allowSelectors = ac.allowSelectors;
+      if (ac.pageviews !== false && !this.config.autocapturePageviews) {
+        this.setupSPATracking();
+      }
+    }
+    if (!captureClicks && !captureForms) return;
+    this.autocaptureModule = new AutocaptureModule(
+      {
+        clicks: captureClicks,
+        forms: captureForms,
+        pageviews: false,
+        // Handled by SPA tracking above
+        blockSelectors,
+        allowSelectors,
+        debug: this.config.debug
+      },
+      (event) => {
+        const name = event.type === "click" ? "$autocapture_click" : event.type === "form_submit" ? "$autocapture_form_submit" : "$autocapture";
+        this.track(name, event.properties);
+      }
+    );
+    this.autocaptureModule.start();
+  }
+  track(eventName, properties) {
+    if (!this.config.enabled) return;
+    const event = this.createEvent("track", { name: eventName, properties });
+    this.enqueue(event);
+    this.log("Track:", eventName, properties);
+  }
+  trackPageView(url, properties) {
+    if (!this.config.enabled) return;
+    const pageUrl = url || (typeof window !== "undefined" ? window.location.href : void 0);
+    const event = this.createEvent("page", {
+      properties: {
+        url: pageUrl,
+        referrer: typeof document !== "undefined" ? document.referrer : void 0,
+        title: typeof document !== "undefined" ? document.title : void 0,
+        ...properties
+      }
+    });
+    this.enqueue(event);
+    this.log("Page view:", pageUrl);
+  }
+  identify(userId, traits) {
+    if (!this.config.enabled) return;
+    this.userId = userId;
+    if (traits) {
+      this.userTraits = { ...this.userTraits, ...traits };
+    }
+    const event = this.createEvent("identify", { traits: this.userTraits || void 0 });
+    this.enqueue(event);
+    this.log("Identify:", userId, traits);
+  }
+  group(groupId, traits) {
+    if (!this.config.enabled) return;
+    this.groupId = groupId;
+    if (traits) {
+      this.groupTraits = { ...this.groupTraits, ...traits };
+    }
+    const event = this.createEvent("group", { traits: this.groupTraits || void 0 });
+    this.enqueue(event);
+    this.log("Group:", groupId, traits);
+  }
+  reset() {
+    this.userId = null;
+    this.groupId = null;
+    this.userTraits = null;
+    this.groupTraits = null;
+    clearSession();
+    this.log("Analytics state reset");
+  }
+  async flush() {
+    if (this.eventQueue.length === 0) return;
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    const endpoint = this.config.eventsEndpoint || `${this.config.endpoint}/api/events`;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        },
+        body: JSON.stringify({ events })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      this.log(`Flushed ${events.length} events`);
+    } catch (err) {
+      this.eventQueue.unshift(...events);
+      this.log("Failed to flush events:", err);
+    }
+  }
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.popstateHandler && typeof window !== "undefined") {
+      window.removeEventListener("popstate", this.popstateHandler);
+      this.popstateHandler = null;
+    }
+    if (this.autocaptureModule) {
+      this.autocaptureModule.stop();
+      this.autocaptureModule = null;
+    }
+    this.flushWithBeacon();
+  }
+  createEvent(type, options) {
+    return {
+      type,
+      name: options.name,
+      properties: options.properties,
+      userId: this.userId || void 0,
+      anonymousId: getAnonymousId(),
+      groupId: this.groupId || void 0,
+      traits: options.traits,
+      sessionId: getSessionId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      url: typeof window !== "undefined" ? window.location.href : void 0,
+      referrer: typeof document !== "undefined" ? document.referrer : void 0,
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0
+    };
+  }
+  enqueue(event) {
+    this.eventQueue.push(event);
+    if (this.eventQueue.length >= this.config.maxBatchSize) {
+      this.flush();
+    }
+  }
+  startFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.config.flushInterval);
+  }
+  setupPageHideListener() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") {
+        this.flushWithBeacon();
+      }
+    });
+  }
+  flushWithBeacon() {
+    if (this.eventQueue.length === 0 || typeof navigator?.sendBeacon !== "function") {
+      return;
+    }
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    const endpoint = this.config.eventsEndpoint || `${this.config.endpoint}/api/events`;
+    const blob = new Blob(
+      [JSON.stringify({ events, apiKey: this.config.apiKey })],
+      { type: "application/json" }
+    );
+    navigator.sendBeacon(endpoint, blob);
+    this.log(`Flushed ${events.length} events via beacon`);
+  }
+  setupSPATracking() {
+    if (typeof window === "undefined") return;
+    this.lastUrl = window.location.href;
+    this.trackPageView();
+    this.popstateHandler = () => {
+      const currentUrl = window.location.href;
+      if (currentUrl !== this.lastUrl) {
+        this.lastUrl = currentUrl;
+        this.trackPageView(currentUrl);
+      }
+    };
+    window.addEventListener("popstate", this.popstateHandler);
+    const originalPushState = history.pushState.bind(history);
+    const originalReplaceState = history.replaceState.bind(history);
+    history.pushState = (...args) => {
+      originalPushState(...args);
+      this.handleUrlChange();
+    };
+    history.replaceState = (...args) => {
+      originalReplaceState(...args);
+      this.handleUrlChange();
+    };
+  }
+  handleUrlChange() {
+    if (typeof window === "undefined") return;
+    const currentUrl = window.location.href;
+    if (currentUrl !== this.lastUrl) {
+      this.lastUrl = currentUrl;
+      this.trackPageView(currentUrl);
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong Analytics]", ...args);
+    }
+  }
+};
+
+// src/fingerprint/tampering.ts
+function detectTampering() {
+  const signals = {
+    uaSpoofed: false,
+    antiDetectBrowser: false,
+    canvasNoise: false,
+    canvasBlocked: false,
+    webglSpoofed: false,
+    webglBlocked: false,
+    vmIndicators: [],
+    platformMismatch: false,
+    pluginAnomaly: false,
+    featureAnomaly: false,
+    geolocationSpoofed: false,
+    mitmIndicators: []
+  };
+  let confidence = 0;
+  const browserResult = detectBrowserTampering(signals);
+  confidence += browserResult;
+  const canvasResult = detectCanvasTampering(signals);
+  confidence += canvasResult;
+  const webglResult = detectWebGLTampering(signals);
+  confidence += webglResult;
+  const vmResult = detectVM(signals);
+  confidence += vmResult;
+  const geoResult = detectGeolocationSpoofing(signals);
+  confidence += geoResult;
+  const mitmResult = detectMitM(signals);
+  confidence += mitmResult;
+  confidence = Math.min(confidence, 1);
+  return {
+    browserTampered: signals.uaSpoofed || signals.antiDetectBrowser || signals.platformMismatch,
+    canvasTampered: signals.canvasNoise || signals.canvasBlocked,
+    webglTampered: signals.webglSpoofed || signals.webglBlocked,
+    vmDetected: signals.vmIndicators.length >= 2,
+    geolocationSpoofed: signals.geolocationSpoofed,
+    mitmDetected: signals.mitmIndicators.length >= 1,
+    confidence,
+    signals
+  };
+}
+function detectBrowserTampering(signals) {
+  if (typeof navigator === "undefined" || typeof window === "undefined") return 0;
+  let score = 0;
+  const ua = navigator.userAgent;
+  const platform = navigator.platform || "";
+  const isWindowsUA = /Windows/.test(ua);
+  const isMacUA = /Mac/.test(ua);
+  const isLinuxUA = /Linux/.test(ua) && !/Android/.test(ua);
+  const isWindowsPlatform = /Win/.test(platform);
+  const isMacPlatform = /Mac/.test(platform);
+  const isLinuxPlatform = /Linux/.test(platform);
+  if (isWindowsUA && !isWindowsPlatform || isMacUA && !isMacPlatform || isLinuxUA && !isLinuxPlatform) {
+    signals.platformMismatch = true;
+    signals.uaSpoofed = true;
+    score += 0.3;
+  }
+  const claimsChrome = /Chrome\/\d+/.test(ua) && !/Edge|OPR|Brave/.test(ua);
+  if (claimsChrome) {
+    const hasChromiumFeatures = "chrome" in window || "CSS" in window && "paintWorklet" in window.CSS;
+    if (!hasChromiumFeatures && !("brave" in navigator)) {
+      signals.uaSpoofed = true;
+      score += 0.2;
+    }
+  }
+  const claimsFirefox = /Firefox\/\d+/.test(ua) && !/Seamonkey/.test(ua);
+  if (claimsFirefox) {
+    const hasFirefoxFeatures = "InstallTrigger" in window || CSS.supports("-moz-appearance", "none");
+    if (!hasFirefoxFeatures) {
+      signals.uaSpoofed = true;
+      score += 0.2;
+    }
+  }
+  const nav = navigator;
+  if (nav.userAgentData?.brands) {
+    const brands = nav.userAgentData.brands.map((b) => b.brand);
+    if (brands.length === 0 || brands.every((b) => b === "" || b === "Not A;Brand")) {
+      signals.antiDetectBrowser = true;
+      score += 0.25;
+    }
+  }
+  if (!/mobile|android|iphone|ipad/i.test(ua)) {
+    const pluginCount = navigator.plugins?.length || 0;
+    if (pluginCount === 0 && claimsChrome) {
+      signals.pluginAnomaly = true;
+      score += 0.1;
+    }
+  }
+  const cores = navigator.hardwareConcurrency || 0;
+  const memory = navigator.deviceMemory || 0;
+  if (cores > 0 && memory > 0) {
+    if (cores >= 16 && memory <= 1) {
+      signals.featureAnomaly = true;
+      score += 0.15;
+    }
+  }
+  return Math.min(score, 0.5);
+}
+function detectCanvasTampering(signals) {
+  if (typeof document === "undefined") return 0;
+  let score = 0;
+  try {
+    const canvas = document.createElement("canvas");
+    canvas.width = 100;
+    canvas.height = 20;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      signals.canvasBlocked = true;
+      return 0.1;
+    }
+    ctx.fillStyle = "#ff0000";
+    ctx.fillRect(0, 0, 100, 20);
+    ctx.fillStyle = "#00ff00";
+    ctx.font = "12px Arial";
+    ctx.fillText("SitePong", 5, 14);
+    const draw1 = canvas.toDataURL();
+    ctx.clearRect(0, 0, 100, 20);
+    ctx.fillStyle = "#ff0000";
+    ctx.fillRect(0, 0, 100, 20);
+    ctx.fillStyle = "#00ff00";
+    ctx.font = "12px Arial";
+    ctx.fillText("SitePong", 5, 14);
+    const draw2 = canvas.toDataURL();
+    if (draw1 !== draw2) {
+      signals.canvasNoise = true;
+      score += 0.35;
+    }
+    const imageData = ctx.getImageData(0, 0, 100, 20);
+    const pixels = imageData.data;
+    let allZero = true;
+    let allSame = true;
+    const firstPixel = pixels[0];
+    for (let i = 0; i < pixels.length; i += 4) {
+      if (pixels[i] !== 0 || pixels[i + 1] !== 0 || pixels[i + 2] !== 0) {
+        allZero = false;
+      }
+      if (pixels[i] !== firstPixel) {
+        allSame = false;
+      }
+    }
+    if (allZero || allSame) {
+      signals.canvasBlocked = true;
+      score += 0.2;
+    }
+    const toDataURLDesc = Object.getOwnPropertyDescriptor(
+      HTMLCanvasElement.prototype,
+      "toDataURL"
+    );
+    if (toDataURLDesc && toDataURLDesc.value !== HTMLCanvasElement.prototype.toDataURL) {
+      signals.canvasNoise = true;
+      score += 0.3;
+    }
+  } catch {
+    signals.canvasBlocked = true;
+    score += 0.1;
+  }
+  return Math.min(score, 0.4);
+}
+function detectWebGLTampering(signals) {
+  if (typeof document === "undefined") return 0;
+  let score = 0;
+  try {
+    const canvas = document.createElement("canvas");
+    const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    if (!gl || !(gl instanceof WebGLRenderingContext)) {
+      signals.webglBlocked = true;
+      return 0.1;
+    }
+    const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+    if (!debugInfo) {
+      signals.webglBlocked = true;
+      return 0.1;
+    }
+    const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+    const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+    const spoofedVendors = ["Brian Paul", "Mesa", "VMware"];
+    const spoofedRenderers = ["llvmpipe", "softpipe", "Mesa", "SwiftShader"];
+    if (spoofedRenderers.some((s) => renderer.includes(s)) && !spoofedVendors.some((v) => vendor.includes(v))) {
+      signals.webglSpoofed = true;
+      score += 0.25;
+    }
+    const ua = navigator.userAgent;
+    const isMobile = /mobile|android|iphone|ipad/i.test(ua);
+    const isDesktopGPU = /GeForce|Radeon|Intel.*HD|GTX|RTX|Vega/i.test(renderer);
+    if (isMobile && isDesktopGPU) {
+      signals.webglSpoofed = true;
+      score += 0.3;
+    }
+    const getParamDesc = Object.getOwnPropertyDescriptor(
+      WebGLRenderingContext.prototype,
+      "getParameter"
+    );
+    if (getParamDesc && typeof getParamDesc.value === "function") {
+      const fnStr = getParamDesc.value.toString();
+      if (!fnStr.includes("[native code]")) {
+        signals.webglSpoofed = true;
+        score += 0.35;
+      }
+    }
+    const extensions = gl.getSupportedExtensions() || [];
+    if (extensions.length < 5 && isDesktopGPU) {
+      signals.webglSpoofed = true;
+      score += 0.1;
+    }
+  } catch {
+    signals.webglBlocked = true;
+    score += 0.1;
+  }
+  return Math.min(score, 0.4);
+}
+function detectVM(signals) {
+  if (typeof navigator === "undefined" || typeof window === "undefined") return 0;
+  const indicators = [];
+  const ua = navigator.userAgent;
+  try {
+    const canvas = document.createElement("canvas");
+    const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    if (gl && gl instanceof WebGLRenderingContext) {
+      const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+      if (debugInfo) {
+        const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL).toLowerCase();
+        const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL).toLowerCase();
+        const vmRenderers = ["vmware", "virtualbox", "hyper-v", "parallels", "qemu", "llvmpipe", "mesa"];
+        const vmVendors = ["vmware", "innotek", "microsoft basic", "parallels"];
+        for (const vm of vmRenderers) {
+          if (renderer.includes(vm)) {
+            indicators.push(`webgl_renderer:${vm}`);
+          }
+        }
+        for (const vm of vmVendors) {
+          if (vendor.includes(vm)) {
+            indicators.push(`webgl_vendor:${vm}`);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  if (typeof screen !== "undefined") {
+    const w = screen.width;
+    const h = screen.height;
+    const vmResolutions = [
+      [800, 600],
+      [1024, 768],
+      [1280, 800]
+    ];
+    if (vmResolutions.some(([vw, vh]) => w === vw && h === vh) && screen.colorDepth === 24 && navigator.hardwareConcurrency <= 2) {
+      indicators.push("vm_resolution");
+    }
+  }
+  const cores = navigator.hardwareConcurrency || 0;
+  const memory = navigator.deviceMemory || 0;
+  if (cores > 0 && cores <= 2 && memory > 0 && memory <= 2) {
+    if (!/mobile|android|iphone/i.test(ua)) {
+      indicators.push("low_hw_specs");
+    }
+  }
+  if (typeof performance !== "undefined") {
+    const times = [];
+    for (let i = 0; i < 10; i++) {
+      times.push(performance.now());
+    }
+    const uniqueTimes = new Set(times.map((t) => Math.floor(t * 1e3)));
+    if (uniqueTimes.size <= 3 && times.length === 10) {
+      indicators.push("coarse_timing");
+    }
+  }
+  if (typeof navigator !== "undefined") {
+    const connection = navigator.connection;
+    if (connection) {
+      if (connection.downlink && connection.downlink >= 10 && connection.rtt && connection.rtt <= 5) {
+        indicators.push("cloud_vm_network");
+      }
+    }
+  }
+  signals.vmIndicators = indicators;
+  const vmScore = Math.min(indicators.length * 0.15, 0.5);
+  return vmScore;
+}
+function detectGeolocationSpoofing(signals) {
+  if (typeof navigator === "undefined") return 0;
+  let score = 0;
+  if ("geolocation" in navigator) {
+    const geoDesc = Object.getOwnPropertyDescriptor(navigator, "geolocation");
+    if (geoDesc && geoDesc.configurable === false && geoDesc.get) {
+      const fnStr = geoDesc.get.toString();
+      if (!fnStr.includes("[native code]")) {
+        signals.geolocationSpoofed = true;
+        score += 0.3;
+      }
+    }
+    try {
+      const getCurrentPositionDesc = Object.getOwnPropertyDescriptor(
+        Geolocation.prototype,
+        "getCurrentPosition"
+      );
+      if (getCurrentPositionDesc?.value) {
+        const fnStr = getCurrentPositionDesc.value.toString();
+        if (!fnStr.includes("[native code]")) {
+          signals.geolocationSpoofed = true;
+          score += 0.3;
+        }
+      }
+    } catch {
+    }
+  }
+  if (typeof window !== "undefined") {
+    try {
+      const navProto = Object.getPrototypeOf(navigator);
+      const geoGetter = Object.getOwnPropertyDescriptor(navProto, "geolocation");
+      if (geoGetter && geoGetter.get && !geoGetter.get.toString().includes("[native code]")) {
+        signals.geolocationSpoofed = true;
+        score += 0.2;
+      }
+    } catch {
+    }
+  }
+  return Math.min(score, 0.4);
+}
+function detectMitM(signals) {
+  if (typeof window === "undefined" || typeof document === "undefined") return 0;
+  const indicators = [];
+  if (window.location?.protocol === "https:") {
+    const scripts = document.querySelectorAll("script[src]");
+    for (let i = 0; i < scripts.length; i++) {
+      const src = scripts[i].getAttribute("src") || "";
+      if (src.startsWith("http://") && !src.includes("localhost")) {
+        indicators.push("mixed_content_script");
+        break;
+      }
+    }
+  }
+  const iframes = document.querySelectorAll("iframe");
+  for (let i = 0; i < iframes.length; i++) {
+    const src = iframes[i].getAttribute("src") || "";
+    if (src && !src.startsWith(window.location?.origin || "") && !src.startsWith("about:") && !src.startsWith("javascript:")) {
+      const style = window.getComputedStyle(iframes[i]);
+      if (style.display === "none" || style.visibility === "hidden" || parseInt(style.width) <= 1 || parseInt(style.height) <= 1) {
+        indicators.push("hidden_iframe");
+      }
+    }
+  }
+  if ("serviceWorker" in navigator) {
+    navigator.serviceWorker.getRegistrations().then((registrations) => {
+      for (const reg of registrations) {
+        const swUrl = reg.active?.scriptURL || "";
+        if (swUrl && !swUrl.startsWith(window.location?.origin || "")) {
+          indicators.push("foreign_service_worker");
+        }
+      }
+    }).catch(() => {
+    });
+  }
+  if (typeof performance !== "undefined" && performance.getEntriesByType) {
+    try {
+      const nav = performance.getEntriesByType("navigation")[0];
+      if (nav) {
+        const connectTime = nav.connectEnd - nav.connectStart;
+        const tlsTime = nav.requestStart - nav.secureConnectionStart;
+        if (connectTime > 1e3 && tlsTime > 500) {
+          indicators.push("slow_tls_handshake");
+        }
+      }
+    } catch {
+    }
+  }
+  if (window.location?.protocol === "https:" && typeof performance !== "undefined") {
+    try {
+      const resources = performance.getEntriesByType("resource");
+      for (const resource of resources.slice(0, 20)) {
+        if (resource.transferSize === 0 && resource.encodedBodySize > 0 && !resource.name.includes("cache")) {
+          indicators.push("intercepted_resource");
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  signals.mitmIndicators = indicators;
+  return Math.min(indicators.length * 0.2, 0.5);
+}
+
+// src/fingerprint/signals.ts
+function collectCoreSignals() {
+  return {
+    userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "",
+    language: typeof navigator !== "undefined" ? navigator.language : "",
+    languages: typeof navigator !== "undefined" ? Array.from(navigator.languages || []) : [],
+    platform: typeof navigator !== "undefined" ? navigator.platform || "" : "",
+    screenWidth: typeof screen !== "undefined" ? screen.width : 0,
+    screenHeight: typeof screen !== "undefined" ? screen.height : 0,
+    screenColorDepth: typeof screen !== "undefined" ? screen.colorDepth : 0,
+    devicePixelRatio: typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1,
+    timezoneOffset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+    timezone: Intl?.DateTimeFormat?.()?.resolvedOptions?.()?.timeZone || "",
+    sessionStorage: hasSessionStorage(),
+    localStorage: hasLocalStorage(),
+    indexedDB: typeof indexedDB !== "undefined",
+    cookieEnabled: typeof navigator !== "undefined" ? navigator.cookieEnabled : false,
+    hardwareConcurrency: typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 0 : 0,
+    maxTouchPoints: typeof navigator !== "undefined" ? navigator.maxTouchPoints || 0 : 0,
+    deviceMemory: typeof navigator !== "undefined" ? navigator.deviceMemory : void 0
+  };
+}
+function collectExtendedSignals() {
+  const signals = {};
+  signals.canvasFingerprint = getCanvasFingerprint();
+  const webgl = getWebGLInfo();
+  signals.webglVendor = webgl.vendor;
+  signals.webglRenderer = webgl.renderer;
+  signals.audioFingerprint = getAudioFingerprint();
+  return signals;
+}
+function collectDeviceSignals(includeExtended) {
+  const core = collectCoreSignals();
+  const signals = { ...core };
+  if (includeExtended) {
+    signals.extended = collectExtendedSignals();
+  }
+  const smart = collectSmartSignals();
+  signals.smart = smart;
+  signals.incognito = smart.incognito;
+  signals.bot = smart.bot;
+  return signals;
+}
+function collectSmartSignals() {
+  const signals = {};
+  signals.incognito = detectIncognito();
+  signals.bot = detectBot();
+  signals.privacyBrowser = detectPrivacyBrowser();
+  signals.devToolsOpen = detectDevTools();
+  signals.connectionType = getConnectionType();
+  signals.doNotTrack = getDoNotTrack();
+  signals.notificationsEnabled = getNotificationsPermission();
+  const deviceAge = getDeviceAge();
+  signals.deviceFirstSeen = deviceAge.firstSeen;
+  signals.deviceVisitCount = deviceAge.visitCount;
+  const tampering = detectTampering();
+  signals.browserTampered = tampering.browserTampered;
+  signals.canvasTampered = tampering.canvasTampered;
+  signals.webglTampered = tampering.webglTampered;
+  signals.vmDetected = tampering.vmDetected;
+  signals.vmIndicators = tampering.signals.vmIndicators;
+  return signals;
+}
+function hasSessionStorage() {
+  try {
+    const key = "__sp_test__";
+    sessionStorage.setItem(key, "1");
+    sessionStorage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasLocalStorage() {
+  try {
+    const key = "__sp_test__";
+    localStorage.setItem(key, "1");
+    localStorage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCanvasFingerprint() {
+  if (typeof document === "undefined") return void 0;
+  try {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return void 0;
+    canvas.width = 200;
+    canvas.height = 50;
+    ctx.textBaseline = "top";
+    ctx.font = "14px Arial";
+    ctx.fillStyle = "#f60";
+    ctx.fillRect(0, 0, 200, 50);
+    ctx.fillStyle = "#069";
+    ctx.fillText("SitePong fingerprint", 2, 15);
+    ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+    ctx.fillText("SitePong fingerprint", 4, 17);
+    return hashString(canvas.toDataURL());
+  } catch {
+    return void 0;
+  }
+}
+function getWebGLInfo() {
+  if (typeof document === "undefined") return {};
+  try {
+    const canvas = document.createElement("canvas");
+    const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    if (!gl || !(gl instanceof WebGLRenderingContext)) return {};
+    const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+    if (!debugInfo) return {};
+    return {
+      vendor: gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL),
+      renderer: gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL)
+    };
+  } catch {
+    return {};
+  }
+}
+function getAudioFingerprint() {
+  if (typeof window === "undefined" || typeof OfflineAudioContext === "undefined") {
+    return void 0;
+  }
+  try {
+    const context = new OfflineAudioContext(1, 44100, 44100);
+    const oscillator = context.createOscillator();
+    oscillator.type = "triangle";
+    oscillator.frequency.setValueAtTime(1e4, context.currentTime);
+    const compressor = context.createDynamicsCompressor();
+    compressor.threshold.setValueAtTime(-50, context.currentTime);
+    compressor.knee.setValueAtTime(40, context.currentTime);
+    compressor.ratio.setValueAtTime(12, context.currentTime);
+    compressor.attack.setValueAtTime(0, context.currentTime);
+    compressor.release.setValueAtTime(0.25, context.currentTime);
+    oscillator.connect(compressor);
+    compressor.connect(context.destination);
+    oscillator.start(0);
+    return hashString(`audio:${context.sampleRate}:${context.length}`);
+  } catch {
+    return void 0;
+  }
+}
+function detectIncognito() {
+  if (typeof window === "undefined") return false;
+  try {
+    const testKey = "__sp_incognito_test__";
+    try {
+      localStorage.setItem(testKey, new Array(100).join("x"));
+      localStorage.removeItem(testKey);
+    } catch {
+      return true;
+    }
+    if (typeof indexedDB !== "undefined") {
+      try {
+        const db = indexedDB.open("__sp_test__");
+        db.onerror = () => {
+        };
+      } catch {
+        return true;
+      }
+    }
+    if ("webkitRequestFileSystem" in window) {
+      let detected = false;
+      try {
+        window.webkitRequestFileSystem(
+          0,
+          1,
+          () => {
+            detected = false;
+          },
+          () => {
+            detected = true;
+          }
+        );
+      } catch {
+      }
+      if (detected) return true;
+    }
+    const perf = performance;
+    if (perf.memory) {
+      const heapLimit = perf.memory.jsHeapSizeLimit || 0;
+      if (heapLimit > 0 && heapLimit < 1073741824) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function detectBot() {
+  if (typeof navigator === "undefined") return false;
+  const ua = navigator.userAgent.toLowerCase();
+  const botPatterns = [
+    "bot",
+    "crawler",
+    "spider",
+    "headless",
+    "phantom",
+    "puppeteer",
+    "selenium",
+    "webdriver",
+    "playwright"
+  ];
+  if (botPatterns.some((pattern) => ua.includes(pattern))) {
+    return true;
+  }
+  if ("webdriver" in navigator && navigator.webdriver) {
+    return true;
+  }
+  if (navigator.plugins && navigator.plugins.length === 0 && !/mobile|android|iphone/i.test(ua)) {
+    return true;
+  }
+  return false;
+}
+function detectPrivacyBrowser() {
+  if (typeof navigator === "undefined") return false;
+  const ua = navigator.userAgent.toLowerCase();
+  if ("brave" in navigator) return true;
+  if (ua.includes("focus") && ua.includes("firefox")) return true;
+  if (ua.includes("duckduckgo")) return true;
+  if (typeof window !== "undefined") {
+    if (screen.width === 1e3 && screen.height === 1e3) return true;
+    if ((/* @__PURE__ */ new Date()).getTimezoneOffset() === 0 && navigator.language !== "en") return true;
+  }
+  return false;
+}
+function detectDevTools() {
+  if (typeof window === "undefined") return false;
+  try {
+    const widthThreshold = window.outerWidth - window.innerWidth > 160;
+    const heightThreshold = window.outerHeight - window.innerHeight > 160;
+    if (widthThreshold || heightThreshold) return true;
+  } catch {
+  }
+  return false;
+}
+function getConnectionType() {
+  if (typeof navigator === "undefined") return void 0;
+  const connection = navigator.connection;
+  if (!connection) return void 0;
+  return connection.effectiveType || connection.type || void 0;
+}
+function getDoNotTrack() {
+  if (typeof navigator === "undefined") return false;
+  const dnt = navigator.doNotTrack;
+  return dnt === "1" || dnt === "yes";
+}
+function getNotificationsPermission() {
+  if (typeof Notification === "undefined") return false;
+  return Notification.permission === "granted";
+}
+function getDeviceAge() {
+  const STORAGE_KEY2 = "sitepong_device_age";
+  const result = { visitCount: 1 };
+  if (typeof localStorage === "undefined") return result;
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY2);
+    if (stored) {
+      const parsed = JSON.parse(stored);
+      result.firstSeen = parsed.firstSeen;
+      result.visitCount = (parsed.visitCount || 0) + 1;
+    } else {
+      result.firstSeen = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    localStorage.setItem(STORAGE_KEY2, JSON.stringify({
+      firstSeen: result.firstSeen,
+      visitCount: result.visitCount
+    }));
+  } catch {
+  }
+  return result;
+}
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16);
+}
+
+// src/fingerprint/behavior.ts
+var BehaviorAnalyzer = class {
+  constructor() {
+    this.mousePoints = [];
+    this.keyDownTimes = /* @__PURE__ */ new Map();
+    this.keyIntervals = [];
+    this.keyHoldTimes = [];
+    this.lastKeyTime = 0;
+    this.scrollEvents = [];
+    this.clickTimes = [];
+    this.running = false;
+    this.maxSamples = 500;
+    this.handleMouseMove = (e) => {
+      if (this.mousePoints.length >= this.maxSamples) return;
+      this.mousePoints.push({ x: e.clientX, y: e.clientY, t: Date.now() });
+    };
+    this.handleKeyDown = (e) => {
+      if (this.keyIntervals.length >= this.maxSamples) return;
+      const now = Date.now();
+      this.keyDownTimes.set(e.key, now);
+      if (this.lastKeyTime > 0) {
+        this.keyIntervals.push(now - this.lastKeyTime);
+      }
+      this.lastKeyTime = now;
+    };
+    this.handleKeyUp = (e) => {
+      const downTime = this.keyDownTimes.get(e.key);
+      if (downTime) {
+        this.keyHoldTimes.push(Date.now() - downTime);
+        this.keyDownTimes.delete(e.key);
+      }
+    };
+    this.handleScroll = () => {
+      if (this.scrollEvents.length >= this.maxSamples) return;
+      this.scrollEvents.push({ deltaY: window.scrollY, t: Date.now() });
+    };
+    this.handleClick = () => {
+      if (this.clickTimes.length >= this.maxSamples) return;
+      this.clickTimes.push(Date.now());
+    };
+  }
+  start() {
+    if (this.running || typeof window === "undefined") return;
+    this.running = true;
+    window.addEventListener("mousemove", this.handleMouseMove, { passive: true });
+    window.addEventListener("keydown", this.handleKeyDown, { passive: true });
+    window.addEventListener("keyup", this.handleKeyUp, { passive: true });
+    window.addEventListener("scroll", this.handleScroll, { passive: true });
+    window.addEventListener("click", this.handleClick, { passive: true });
+  }
+  stop() {
+    if (!this.running || typeof window === "undefined") return;
+    this.running = false;
+    window.removeEventListener("mousemove", this.handleMouseMove);
+    window.removeEventListener("keydown", this.handleKeyDown);
+    window.removeEventListener("keyup", this.handleKeyUp);
+    window.removeEventListener("scroll", this.handleScroll);
+    window.removeEventListener("click", this.handleClick);
+  }
+  getMetrics() {
+    const mouse = this.analyzeMouseMovement();
+    const keyboard = this.analyzeKeyboard();
+    const scroll = this.analyzeScroll();
+    const clicks = this.analyzeClicks();
+    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 = [];
+  }
+  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_ENDPOINT3 = "https://ingest.sitepong.com";
+var CACHE_KEY = "sitepong_visitor";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var FingerprintManager = class {
+  constructor(config) {
+    this.cachedVisitor = null;
+    this.pendingRequest = null;
+    this.config = {
+      endpoint: DEFAULT_ENDPOINT3,
+      enabled: true,
+      debug: false,
+      ...config
+    };
+    this.behaviorAnalyzer = new BehaviorAnalyzer();
+    if (this.config.enabled && typeof window !== "undefined") {
+      this.behaviorAnalyzer.start();
+    }
+    this.loadFromStorage();
+  }
+  async getVisitorId() {
+    if (!this.config.enabled) {
+      throw new Error("Fingerprint is not enabled");
+    }
+    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 endpoint = this.config.visitorEndpoint || `${this.config.endpoint}/api/visitors`;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        },
+        body: JSON.stringify({ signals })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const result = await response.json();
+      this.cachedVisitor = {
+        result,
+        signals,
+        cachedAt: Date.now()
+      };
+      this.saveToStorage();
+      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;
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong Fingerprint]", ...args);
+    }
+  }
+};
+
+// src/replay/serializer.ts
+var nodeIdCounter = 0;
+var nodeIdMap = /* @__PURE__ */ new WeakMap();
+function resetNodeIds() {
+  nodeIdCounter = 0;
+}
+function getNodeId(node) {
+  let id = nodeIdMap.get(node);
+  if (id === void 0) {
+    id = ++nodeIdCounter;
+    nodeIdMap.set(node, id);
+  }
+  return id;
+}
+function serializeNode(node, options) {
+  const id = getNodeId(node);
+  if (node.nodeType === Node.TEXT_NODE) {
+    const parent = node.parentElement;
+    let textContent = node.textContent || "";
+    if (parent && options.maskSelector && parent.matches(options.maskSelector)) {
+      textContent = textContent.replace(/\S/g, "*");
+    }
+    return {
+      id,
+      type: "text",
+      textContent
+    };
+  }
+  if (node.nodeType === Node.COMMENT_NODE) {
+    return { id, type: "comment", textContent: "" };
+  }
+  if (node.nodeType === Node.ELEMENT_NODE) {
+    const el = node;
+    if (options.blockSelector && el.matches(options.blockSelector)) {
+      return {
+        id,
+        type: "element",
+        tagName: "div",
+        attributes: {
+          "data-blocked": "true",
+          style: `width:${el.offsetWidth}px;height:${el.offsetHeight}px;background:#f0f0f0;`
+        }
+      };
+    }
+    const tagName = el.tagName.toLowerCase();
+    const attributes = {};
+    if (tagName === "script" || tagName === "noscript") {
+      return { id, type: "element", tagName, attributes: {} };
+    }
+    for (const attr of Array.from(el.attributes)) {
+      if (attr.name.startsWith("on")) continue;
+      if (attr.name === "value" && options.maskInputs && isInputElement(el)) {
+        attributes[attr.name] = "***";
+        continue;
+      }
+      attributes[attr.name] = attr.value;
+    }
+    if (options.maskInputs && isInputElement(el)) {
+      const input = el;
+      if (input.type !== "checkbox" && input.type !== "radio" && input.type !== "submit" && input.type !== "button") {
+        attributes["value"] = "***";
+      }
+    }
+    const children = [];
+    if (tagName !== "style") {
+      for (const child of Array.from(el.childNodes)) {
+        const serialized = serializeNode(child, options);
+        if (serialized) {
+          children.push(serialized);
+        }
+      }
+    } else {
+      const textContent = el.textContent || "";
+      if (textContent) {
+        children.push({
+          id: getNodeId(el.firstChild || el),
+          type: "text",
+          textContent
+        });
+      }
+    }
+    return {
+      id,
+      type: "element",
+      tagName,
+      attributes,
+      children,
+      isSVG: el instanceof SVGElement
+    };
+  }
+  return null;
+}
+function takeSnapshot(options) {
+  if (typeof document === "undefined") return null;
+  resetNodeIds();
+  const html = serializeNode(document.documentElement, options);
+  if (!html) return null;
+  return {
+    doctype: document.doctype ? `<!DOCTYPE ${document.doctype.name}>` : void 0,
+    html,
+    width: window.innerWidth,
+    height: window.innerHeight
+  };
+}
+function isInputElement(el) {
+  const tag = el.tagName.toLowerCase();
+  return tag === "input" || tag === "textarea" || tag === "select";
+}
+
+// src/replay/network.ts
+var REDACTED_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token"
+];
+var NetworkRecorder = class {
+  constructor(callback, options) {
+    this.originalFetch = null;
+    this.originalXhrOpen = null;
+    this.originalXhrSend = null;
+    this.active = false;
+    this.callback = callback;
+    this.captureHeaders = options?.captureHeaders ?? false;
+    this.urlFilter = options?.urlFilter;
+  }
+  start() {
+    if (this.active || typeof window === "undefined") return;
+    this.active = true;
+    this.interceptFetch();
+    this.interceptXHR();
+  }
+  stop() {
+    if (!this.active) return;
+    this.active = false;
+    if (this.originalFetch) {
+      window.fetch = this.originalFetch;
+      this.originalFetch = null;
+    }
+    if (this.originalXhrOpen) {
+      XMLHttpRequest.prototype.open = this.originalXhrOpen;
+      this.originalXhrOpen = null;
+    }
+    if (this.originalXhrSend) {
+      XMLHttpRequest.prototype.send = this.originalXhrSend;
+      this.originalXhrSend = null;
+    }
+  }
+  interceptFetch() {
+    if (typeof window.fetch !== "function") return;
+    this.originalFetch = window.fetch;
+    const self = this;
+    window.fetch = async function(input, init2) {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+      if (self.urlFilter && !self.urlFilter(url)) {
+        return self.originalFetch.call(window, input, init2);
+      }
+      const startTime = Date.now();
+      const method = init2?.method || (input instanceof Request ? input.method : "GET");
+      let requestSize;
+      if (init2?.body) {
+        if (typeof init2.body === "string") {
+          requestSize = init2.body.length;
+        } else if (init2.body instanceof Blob) {
+          requestSize = init2.body.size;
+        }
+      }
+      try {
+        const response = await self.originalFetch.call(window, input, init2);
+        const duration = Date.now() - startTime;
+        const data = {
+          method: method.toUpperCase(),
+          url: self.truncateUrl(url),
+          status: response.status,
+          statusText: response.statusText,
+          duration,
+          requestSize,
+          initiator: "fetch"
+        };
+        if (self.captureHeaders) {
+          data.requestHeaders = self.safeHeaders(init2?.headers);
+          data.responseHeaders = self.headersToObject(response.headers);
+        }
+        self.emit(data);
+        return response;
+      } catch (err) {
+        const duration = Date.now() - startTime;
+        self.emit({
+          method: method.toUpperCase(),
+          url: self.truncateUrl(url),
+          duration,
+          requestSize,
+          error: err instanceof Error ? err.message : "Network error",
+          initiator: "fetch"
+        });
+        throw err;
+      }
+    };
+  }
+  interceptXHR() {
+    if (typeof XMLHttpRequest === "undefined") return;
+    this.originalXhrOpen = XMLHttpRequest.prototype.open;
+    this.originalXhrSend = XMLHttpRequest.prototype.send;
+    const self = this;
+    XMLHttpRequest.prototype.open = function(method, url, ...args) {
+      this._spMethod = method;
+      this._spUrl = typeof url === "string" ? url : url.toString();
+      return self.originalXhrOpen.apply(this, [method, url, ...args]);
+    };
+    XMLHttpRequest.prototype.send = function(body) {
+      const xhr = this;
+      const url = xhr._spUrl;
+      if (self.urlFilter && !self.urlFilter(url)) {
+        return self.originalXhrSend.call(this, body);
+      }
+      const startTime = Date.now();
+      let requestSize;
+      if (typeof body === "string") {
+        requestSize = body.length;
+      }
+      const onLoadEnd = () => {
+        const duration = Date.now() - startTime;
+        const data = {
+          method: (xhr._spMethod || "GET").toUpperCase(),
+          url: self.truncateUrl(url),
+          status: xhr.status,
+          statusText: xhr.statusText,
+          duration,
+          requestSize,
+          responseSize: xhr.responseText?.length,
+          initiator: "xhr"
+        };
+        if (xhr.status === 0) {
+          data.error = "Network error";
+        }
+        self.emit(data);
+        xhr.removeEventListener("loadend", onLoadEnd);
+      };
+      xhr.addEventListener("loadend", onLoadEnd);
+      return self.originalXhrSend.call(this, body);
+    };
+  }
+  emit(data) {
+    if (!this.active) return;
+    this.callback({
+      type: "network",
+      timestamp: Date.now(),
+      data
+    });
+  }
+  truncateUrl(url) {
+    try {
+      const parsed = new URL(url, window.location.origin);
+      const path = parsed.pathname + parsed.search;
+      return path.length > 500 ? path.slice(0, 500) + "..." : parsed.origin + path;
+    } catch {
+      return url.length > 500 ? url.slice(0, 500) + "..." : url;
+    }
+  }
+  safeHeaders(headers) {
+    if (!headers) return void 0;
+    const result = {};
+    if (headers instanceof Headers) {
+      headers.forEach((value, key) => {
+        result[key] = REDACTED_HEADERS.includes(key.toLowerCase()) ? "[REDACTED]" : value;
+      });
+    } else if (Array.isArray(headers)) {
+      for (const [key, value] of headers) {
+        result[key] = REDACTED_HEADERS.includes(key.toLowerCase()) ? "[REDACTED]" : value;
+      }
+    } else {
+      for (const [key, value] of Object.entries(headers)) {
+        result[key] = REDACTED_HEADERS.includes(key.toLowerCase()) ? "[REDACTED]" : value;
+      }
+    }
+    return result;
+  }
+  headersToObject(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+      result[key] = REDACTED_HEADERS.includes(key.toLowerCase()) ? "[REDACTED]" : value;
+    });
+    return result;
+  }
+};
+
+// src/replay/console.ts
+var MAX_ARG_LENGTH = 1e3;
+var MAX_ARGS = 10;
+var MAX_TRACE_LENGTH = 2e3;
+var ConsoleRecorder = class {
+  constructor(callback, options) {
+    this.originals = {};
+    this.active = false;
+    this.callback = callback;
+    this.levels = options?.levels || ["log", "info", "warn", "error", "debug"];
+  }
+  start() {
+    if (this.active || typeof console === "undefined") return;
+    this.active = true;
+    for (const level of this.levels) {
+      this.originals[level] = console[level].bind(console);
+      console[level] = (...args) => {
+        this.originals[level](...args);
+        this.record(level, args);
+      };
+    }
+  }
+  stop() {
+    if (!this.active) return;
+    this.active = false;
+    for (const level of this.levels) {
+      if (this.originals[level]) {
+        console[level] = this.originals[level];
+      }
+    }
+    this.originals = {};
+  }
+  record(level, args) {
+    if (!this.active) return;
+    if (args.length > 0 && typeof args[0] === "string" && args[0].startsWith("[SitePong")) {
+      return;
+    }
+    const serializedArgs = args.slice(0, MAX_ARGS).map((arg) => this.serialize(arg));
+    const data = {
+      level,
+      args: serializedArgs
+    };
+    if (level === "error") {
+      const trace = this.getStackTrace();
+      if (trace) {
+        data.trace = trace.slice(0, MAX_TRACE_LENGTH);
+      }
+    }
+    this.callback({
+      type: "console",
+      timestamp: Date.now(),
+      data
+    });
+  }
+  serialize(value) {
+    if (value === null) return "null";
+    if (value === void 0) return "undefined";
+    if (value instanceof Error) {
+      return `Error: ${value.message}${value.stack ? "\n" + value.stack : ""}`.slice(0, MAX_ARG_LENGTH);
+    }
+    if (typeof value === "string") {
+      return value.slice(0, MAX_ARG_LENGTH);
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return String(value);
+    }
+    if (typeof value === "function") {
+      return `[Function: ${value.name || "anonymous"}]`;
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    if (value instanceof HTMLElement) {
+      return `<${value.tagName.toLowerCase()}${value.id ? "#" + value.id : ""}${value.className ? "." + value.className.split(" ").join(".") : ""}>`;
+    }
+    try {
+      const str = JSON.stringify(value, this.getReplacer(), 0);
+      return str ? str.slice(0, MAX_ARG_LENGTH) : String(value);
+    } catch {
+      return String(value).slice(0, MAX_ARG_LENGTH);
+    }
+  }
+  getReplacer() {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return (_key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) return "[Circular]";
+        seen.add(value);
+      }
+      if (typeof value === "function") return "[Function]";
+      if (value instanceof RegExp) return value.toString();
+      return value;
+    };
+  }
+  getStackTrace() {
+    try {
+      const err = new Error();
+      if (!err.stack) return void 0;
+      const lines = err.stack.split("\n");
+      return lines.slice(4).join("\n") || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/replay/manager.ts
+var DEFAULT_ENDPOINT4 = "https://ingest.sitepong.com";
+var DEFAULT_FLUSH_INTERVAL2 = 5e3;
+var DEFAULT_MAX_BATCH_SIZE = 100;
+var DEFAULT_MAX_SESSION_DURATION = 60 * 60 * 1e3;
+var ReplayManager = class {
+  constructor(config) {
+    this.recording = false;
+    this.sessionId = null;
+    this.events = [];
+    this.flushTimer = null;
+    this.sessionStartTime = 0;
+    this.observer = null;
+    this.mouseMoveBuffer = [];
+    this.mouseMoveFlushTimer = null;
+    this.cleanupFns = [];
+    this.networkRecorder = null;
+    this.consoleRecorder = null;
+    this.lastSnapshotTime = 0;
+    this.snapshotCooldown = 500;
+    // min ms between interaction snapshots
+    this.userContext = null;
+    this.config = {
+      endpoint: DEFAULT_ENDPOINT4,
+      enabled: true,
+      maskInputs: true,
+      maxSessionDuration: DEFAULT_MAX_SESSION_DURATION,
+      flushInterval: DEFAULT_FLUSH_INTERVAL2,
+      maxBatchSize: DEFAULT_MAX_BATCH_SIZE,
+      sampleRate: 1,
+      debug: false,
+      ...config
+    };
+  }
+  start() {
+    if (typeof window === "undefined") return false;
+    if (this.recording) return true;
+    if (!this.config.enabled) return false;
+    if (Math.random() > this.config.sampleRate) {
+      this.log("Session not sampled");
+      return false;
+    }
+    this.sessionId = this.getOrCreateSessionId();
+    this.sessionStartTime = this.getOrCreateStartTime();
+    this.recording = true;
+    this.events = [];
+    const snapshot = takeSnapshot({
+      maskInputs: this.config.maskInputs,
+      blockSelector: this.config.blockSelector,
+      maskSelector: this.config.maskSelector
+    });
+    if (snapshot) {
+      this.addEvent("snapshot", snapshot);
+    }
+    this.setupMutationObserver();
+    this.setupEventListeners();
+    this.setupNetworkRecording();
+    this.setupConsoleRecording();
+    this.startFlushTimer();
+    this.log("Recording started:", this.sessionId);
+    return true;
+  }
+  stop() {
+    if (!this.recording) return;
+    this.recording = false;
+    this.flush();
+    if (this.observer) {
+      this.observer.disconnect();
+      this.observer = null;
+    }
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.mouseMoveFlushTimer) {
+      clearTimeout(this.mouseMoveFlushTimer);
+      this.mouseMoveFlushTimer = null;
+    }
+    if (this.networkRecorder) {
+      this.networkRecorder.stop();
+      this.networkRecorder = null;
+    }
+    if (this.consoleRecorder) {
+      this.consoleRecorder.stop();
+      this.consoleRecorder = null;
+    }
+    for (const cleanup of this.cleanupFns) {
+      cleanup();
+    }
+    this.cleanupFns = [];
+    this.log("Recording stopped:", this.sessionId);
+    this.sessionId = null;
+  }
+  isRecording() {
+    return this.recording;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setUser(user) {
+    this.userContext = user;
+  }
+  addEvent(type, data) {
+    if (!this.recording) return;
+    if (Date.now() - this.sessionStartTime > this.config.maxSessionDuration) {
+      this.stop();
+      return;
+    }
+    this.events.push({
+      type,
+      timestamp: Date.now() - this.sessionStartTime,
+      data
+    });
+    if (this.events.length >= this.config.maxBatchSize) {
+      this.flush();
+    }
+  }
+  setupMutationObserver() {
+    if (typeof MutationObserver === "undefined") return;
+    this.observer = new MutationObserver((mutations) => {
+      const mutationData = {
+        adds: [],
+        removes: [],
+        attributes: [],
+        texts: []
+      };
+      for (const mutation of mutations) {
+        switch (mutation.type) {
+          case "childList": {
+            for (const node of Array.from(mutation.addedNodes)) {
+              const serialized = serializeNode(node, {
+                maskInputs: this.config.maskInputs,
+                blockSelector: this.config.blockSelector,
+                maskSelector: this.config.maskSelector
+              });
+              if (serialized) {
+                mutationData.adds.push({
+                  parentId: getNodeId(mutation.target),
+                  nextId: mutation.nextSibling ? getNodeId(mutation.nextSibling) : null,
+                  node: serialized
+                });
+              }
+            }
+            for (const node of Array.from(mutation.removedNodes)) {
+              mutationData.removes.push({
+                parentId: getNodeId(mutation.target),
+                id: getNodeId(node)
+              });
+            }
+            break;
+          }
+          case "attributes": {
+            const el = mutation.target;
+            const value = el.getAttribute(mutation.attributeName || "");
+            mutationData.attributes.push({
+              id: getNodeId(mutation.target),
+              attributes: { [mutation.attributeName || ""]: value }
+            });
+            break;
+          }
+          case "characterData": {
+            let textValue = mutation.target.textContent || "";
+            const parent = mutation.target.parentElement;
+            if (parent && this.config.maskSelector && parent.matches(this.config.maskSelector)) {
+              textValue = textValue.replace(/\S/g, "*");
+            }
+            mutationData.texts.push({
+              id: getNodeId(mutation.target),
+              value: textValue
+            });
+            break;
+          }
+        }
+      }
+      if (mutationData.adds.length || mutationData.removes.length || mutationData.attributes.length || mutationData.texts.length) {
+        this.addEvent("mutation", mutationData);
+      }
+    });
+    this.observer.observe(document.documentElement, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      characterData: true,
+      attributeOldValue: false
+    });
+  }
+  setupEventListeners() {
+    const onMouseMove = (e) => {
+      this.mouseMoveBuffer.push({
+        x: e.clientX,
+        y: e.clientY,
+        t: Date.now() - this.sessionStartTime
+      });
+      if (!this.mouseMoveFlushTimer) {
+        this.mouseMoveFlushTimer = setTimeout(() => {
+          if (this.mouseMoveBuffer.length > 0) {
+            const data = { positions: [...this.mouseMoveBuffer] };
+            this.addEvent("mouse_move", data);
+            this.mouseMoveBuffer = [];
+          }
+          this.mouseMoveFlushTimer = null;
+        }, 50);
+      }
+    };
+    const onClick = (e) => {
+      const target = e.target;
+      this.addEvent("mouse_click", {
+        x: e.clientX,
+        y: e.clientY,
+        targetId: getNodeId(target),
+        button: e.button
+      });
+      this.takeInteractionSnapshot();
+    };
+    const onContextMenu = (e) => {
+      const target = e.target;
+      this.addEvent("mouse_click", {
+        x: e.clientX,
+        y: e.clientY,
+        targetId: getNodeId(target),
+        button: 2
+      });
+      this.takeInteractionSnapshot();
+    };
+    const onMouseLeave = () => {
+      this.addEvent("mouse_leave", {});
+    };
+    const onTouchStart = (e) => {
+      const touch = e.touches[0];
+      if (!touch) return;
+      const target = e.target;
+      this.addEvent("touch", {
+        x: touch.clientX,
+        y: touch.clientY,
+        targetId: getNodeId(target)
+      });
+      this.takeInteractionSnapshot();
+    };
+    let scrollSnapshotTimer = null;
+    const onScroll = () => {
+      const data = {
+        id: 0,
+        // document scroll
+        x: window.scrollX,
+        y: window.scrollY
+      };
+      this.addEvent("scroll", data);
+      if (scrollSnapshotTimer) clearTimeout(scrollSnapshotTimer);
+      scrollSnapshotTimer = setTimeout(() => {
+        this.takeInteractionSnapshot();
+      }, 250);
+    };
+    const onInput = (e) => {
+      const target = e.target;
+      if (!target) return;
+      const data = {
+        id: getNodeId(target),
+        value: this.config.maskInputs ? "***" : target.value
+      };
+      if ("checked" in target) {
+        data.isChecked = target.checked;
+      }
+      this.addEvent("input", data);
+    };
+    const onResize = () => {
+      this.addEvent("resize", {
+        width: window.innerWidth,
+        height: window.innerHeight
+      });
+    };
+    const onFocus = (e) => {
+      if (e.target && e.target !== document) {
+        this.addEvent("focus", { id: getNodeId(e.target) });
+      }
+    };
+    const onBlur = (e) => {
+      if (e.target && e.target !== document) {
+        this.addEvent("blur", { id: getNodeId(e.target) });
+      }
+    };
+    const onVisibilityChange = () => {
+      if (document.visibilityState === "hidden") {
+        this.flush();
+      }
+    };
+    document.addEventListener("mousemove", onMouseMove, { passive: true });
+    document.addEventListener("click", onClick, { passive: true });
+    document.addEventListener("contextmenu", onContextMenu, { passive: true });
+    document.documentElement.addEventListener("mouseleave", onMouseLeave, { passive: true });
+    document.addEventListener("touchstart", onTouchStart, { passive: true });
+    window.addEventListener("scroll", onScroll, { passive: true });
+    document.addEventListener("input", onInput, { passive: true });
+    window.addEventListener("resize", onResize, { passive: true });
+    document.addEventListener("focus", onFocus, { passive: true, capture: true });
+    document.addEventListener("blur", onBlur, { passive: true, capture: true });
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    this.cleanupFns.push(
+      () => document.removeEventListener("mousemove", onMouseMove),
+      () => document.removeEventListener("click", onClick),
+      () => document.removeEventListener("contextmenu", onContextMenu),
+      () => document.documentElement.removeEventListener("mouseleave", onMouseLeave),
+      () => document.removeEventListener("touchstart", onTouchStart),
+      () => window.removeEventListener("scroll", onScroll),
+      () => document.removeEventListener("input", onInput),
+      () => window.removeEventListener("resize", onResize),
+      () => document.removeEventListener("focus", onFocus, { capture: true }),
+      () => document.removeEventListener("blur", onBlur, { capture: true }),
+      () => document.removeEventListener("visibilitychange", onVisibilityChange)
+    );
+  }
+  setupNetworkRecording() {
+    if (!this.config.recordNetwork) return;
+    const sdkEndpoint = this.config.replayEndpoint || this.config.endpoint;
+    this.networkRecorder = new NetworkRecorder(
+      (event) => {
+        this.addEvent("network", event.data);
+      },
+      {
+        captureHeaders: this.config.captureNetworkHeaders,
+        // Skip recording our own SDK API calls
+        urlFilter: (url) => !url.startsWith(sdkEndpoint)
+      }
+    );
+    this.networkRecorder.start();
+  }
+  setupConsoleRecording() {
+    if (!this.config.recordConsole) return;
+    this.consoleRecorder = new ConsoleRecorder(
+      (event) => {
+        this.addEvent("console", event.data);
+      },
+      {
+        levels: this.config.consoleLevels
+      }
+    );
+    this.consoleRecorder.start();
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.config.flushInterval);
+  }
+  async flush() {
+    if (this.events.length === 0 || !this.sessionId) return;
+    const events = [...this.events];
+    this.events = [];
+    const endpoint = this.config.replayEndpoint || `${this.config.endpoint}/api/replays`;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        },
+        body: JSON.stringify({
+          sessionId: this.sessionId,
+          events,
+          startedAt: new Date(this.sessionStartTime).toISOString(),
+          pageUrl: typeof location !== "undefined" ? location.href : void 0,
+          pageTitle: typeof document !== "undefined" ? document.title : void 0,
+          userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+          userId: this.userContext?.id
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      this.log(`Flushed ${events.length} replay events`);
+    } catch (err) {
+      this.events.unshift(...events);
+      this.log("Failed to flush replay events:", err);
+    }
+  }
+  takeInteractionSnapshot() {
+    const now = Date.now();
+    if (now - this.lastSnapshotTime < this.snapshotCooldown) return;
+    this.lastSnapshotTime = now;
+    const snapshot = takeSnapshot({
+      maskInputs: this.config.maskInputs,
+      blockSelector: this.config.blockSelector,
+      maskSelector: this.config.maskSelector
+    });
+    if (snapshot) {
+      this.addEvent("snapshot", snapshot);
+    }
+  }
+  getOrCreateSessionId() {
+    const storageKey = "__sp_replay_session";
+    try {
+      const existing = sessionStorage.getItem(storageKey);
+      if (existing) return existing;
+    } catch {
+    }
+    const id = `rep_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+    try {
+      sessionStorage.setItem(storageKey, id);
+    } catch {
+    }
+    return id;
+  }
+  getOrCreateStartTime() {
+    const storageKey = "__sp_replay_start";
+    try {
+      const existing = sessionStorage.getItem(storageKey);
+      if (existing) return parseInt(existing, 10);
+    } catch {
+    }
+    const now = Date.now();
+    try {
+      sessionStorage.setItem(storageKey, String(now));
+    } catch {
+    }
+    return now;
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong Replay]", ...args);
+    }
+  }
+};
+
+// src/performance/manager.ts
+var DEFAULT_ENDPOINT5 = "https://ingest.sitepong.com";
+var DEFAULT_FLUSH_INTERVAL3 = 1e4;
+var PerformanceManager = class {
+  constructor(config) {
+    this.metrics = [];
+    this.flushTimer = null;
+    this.vitals = {};
+    this.activeTransactions = /* @__PURE__ */ new Map();
+    this.config = {
+      endpoint: DEFAULT_ENDPOINT5,
+      enabled: true,
+      webVitals: true,
+      navigationTiming: true,
+      resourceTiming: false,
+      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") return;
+    if (this.config.webVitals) {
+      this.observeWebVitals();
+    }
+    if (this.config.navigationTiming) {
+      this.collectNavigationTiming();
+    }
+    this.startFlushTimer();
+    this.log("Performance monitoring initialized");
+  }
+  /**
+   * Start a custom transaction for measuring operations
+   */
+  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;
+  }
+  /**
+   * End a transaction and report it
+   */
+  endTransaction(id, status = "ok") {
+    const transaction = this.activeTransactions.get(id);
+    if (!transaction) {
+      this.log("Transaction not found:", id);
+      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.href : void 0,
+      transaction
+    });
+    this.log("Transaction ended:", transaction.name, `${transaction.duration.toFixed(1)}ms`);
+  }
+  /**
+   * Start a span within a transaction
+   */
+  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;
+  }
+  /**
+   * End a span
+   */
+  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;
+  }
+  /**
+   * Get current Web Vitals
+   */
+  getVitals() {
+    return { ...this.vitals };
+  }
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+  }
+  observeWebVitals() {
+    if (typeof PerformanceObserver === "undefined") return;
+    try {
+      const lcpObserver = new PerformanceObserver((list) => {
+        const entries = list.getEntries();
+        const lastEntry = entries[entries.length - 1];
+        if (lastEntry) {
+          this.vitals.lcp = lastEntry.startTime;
+          this.reportVital("LCP", lastEntry.startTime);
+        }
+      });
+      lcpObserver.observe({ type: "largest-contentful-paint", buffered: true });
+    } catch (e) {
+    }
+    try {
+      const fidObserver = new PerformanceObserver((list) => {
+        const entry = list.getEntries()[0];
+        if (entry) {
+          const fid = entry.processingStart - entry.startTime;
+          this.vitals.fid = fid;
+          this.reportVital("FID", fid);
+        }
+      });
+      fidObserver.observe({ type: "first-input", buffered: true });
+    } catch (e) {
+    }
+    try {
+      let clsValue = 0;
+      const clsObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          const layoutShift = entry;
+          if (!layoutShift.hadRecentInput) {
+            clsValue += layoutShift.value;
+          }
+        }
+        this.vitals.cls = clsValue;
+      });
+      clsObserver.observe({ type: "layout-shift", buffered: true });
+      if (typeof document !== "undefined") {
+        document.addEventListener("visibilitychange", () => {
+          if (document.visibilityState === "hidden" && clsValue > 0) {
+            this.reportVital("CLS", clsValue, "score");
+          }
+        });
+      }
+    } catch (e) {
+    }
+    try {
+      const fcpObserver = new PerformanceObserver((list) => {
+        const entry = list.getEntries().find(
+          (e) => e.name === "first-contentful-paint"
+        );
+        if (entry) {
+          this.vitals.fcp = entry.startTime;
+          this.reportVital("FCP", entry.startTime);
+        }
+      });
+      fcpObserver.observe({ type: "paint", buffered: true });
+    } catch (e) {
+    }
+    try {
+      let maxINP = 0;
+      const inpObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          const duration = entry.duration;
+          if (duration > maxINP) {
+            maxINP = duration;
+            this.vitals.inp = maxINP;
+          }
+        }
+      });
+      inpObserver.observe({ type: "event", buffered: true });
+    } catch (e) {
+    }
+  }
+  collectNavigationTiming() {
+    if (typeof window === "undefined" || !window.performance) return;
+    const collect = () => {
+      const nav = performance.getEntriesByType("navigation")[0];
+      if (!nav) return;
+      const ttfb = nav.responseStart - nav.requestStart;
+      this.vitals.ttfb = ttfb;
+      this.reportVital("TTFB", ttfb);
+      this.addMetric({
+        type: "navigation",
+        name: "page_load",
+        value: nav.loadEventEnd - nav.startTime,
+        unit: "ms",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        url: window.location.href,
+        data: {
+          dns: nav.domainLookupEnd - nav.domainLookupStart,
+          tcp: nav.connectEnd - nav.connectStart,
+          ttfb,
+          domContentLoaded: nav.domContentLoadedEventEnd - nav.startTime,
+          domComplete: nav.domComplete - nav.startTime,
+          transferSize: nav.transferSize,
+          encodedBodySize: nav.encodedBodySize,
+          decodedBodySize: nav.decodedBodySize
+        }
+      });
+    };
+    if (document.readyState === "complete") {
+      setTimeout(collect, 0);
+    } else {
+      window.addEventListener("load", () => setTimeout(collect, 0));
+    }
+  }
+  reportVital(name, value, unit = "ms") {
+    this.addMetric({
+      type: "web_vital",
+      name,
+      value,
+      unit,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      url: typeof window !== "undefined" ? 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;
+    const metrics = [...this.metrics];
+    this.metrics = [];
+    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.log(`Flushed ${metrics.length} performance metrics`);
+    } catch (err) {
+      this.metrics.unshift(...metrics);
+      this.log("Failed to flush metrics:", 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;
+    }
+  }
+};
+
+// src/crons.ts
+var CronMonitorManager = class {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.endpoint = config.endpoint;
+    this.debug = config.debug || false;
+  }
+  /**
+   * Send a check-in for a cron monitor
+   */
+  async checkin(slug, options = {}) {
+    try {
+      const response = await fetch(`${this.endpoint}/api/sdk/crons`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify({
+          slug,
+          status: options.status || "ok",
+          duration_ms: options.duration_ms,
+          message: options.message,
+          environment: options.environment
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      this.log(`Check-in sent for "${slug}" (${options.status || "ok"})`);
+    } catch (err) {
+      this.log("Failed to send check-in:", err);
+    }
+  }
+  /**
+   * Start tracking a cron job execution.
+   * Returns a handle with ok() and error() methods to complete the check-in.
+   */
+  start(slug, environment) {
+    const startTime = Date.now();
+    this.checkin(slug, { status: "in_progress", environment });
+    return {
+      ok: async (message) => {
+        const duration_ms = Date.now() - startTime;
+        await this.checkin(slug, { status: "ok", duration_ms, message, environment });
+      },
+      error: async (message) => {
+        const duration_ms = Date.now() - startTime;
+        await this.checkin(slug, { status: "error", duration_ms, message, environment });
+      }
+    };
+  }
+  /**
+   * Wrap an async function with automatic cron monitoring.
+   * Sends 'in_progress' on start, 'ok' on success, 'error' on failure.
+   */
+  wrap(slug, fn, environment) {
+    const handle = this.start(slug, environment);
+    return fn().then(
+      async (result) => {
+        await handle.ok();
+        return result;
+      },
+      async (err) => {
+        await handle.error(err?.message || String(err));
+        throw err;
+      }
+    );
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[SitePong:Cron]", ...args);
+    }
+  }
+};
+
+// src/metrics.ts
+var MetricsManager = class {
+  constructor(config) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.apiKey = config.apiKey;
+    this.endpoint = config.endpoint;
+    this.debug = config.debug || false;
+    this.flushInterval = config.flushInterval || 1e4;
+    this.maxBatchSize = config.maxBatchSize || 100;
+    this.startFlushTimer();
+  }
+  /**
+   * Increment a counter metric
+   */
+  increment(name, value = 1, options) {
+    this.enqueue(name, value, "counter", options);
+  }
+  /**
+   * Decrement a counter metric
+   */
+  decrement(name, value = 1, options) {
+    this.enqueue(name, -value, "counter", options);
+  }
+  /**
+   * Set a gauge metric (instantaneous value)
+   */
+  gauge(name, value, options) {
+    this.enqueue(name, value, "gauge", options);
+  }
+  /**
+   * Record a histogram value (for aggregation server-side)
+   */
+  histogram(name, value, options) {
+    this.enqueue(name, value, "histogram", options);
+  }
+  /**
+   * Record a distribution value (for percentile calculations)
+   */
+  distribution(name, value, options) {
+    this.enqueue(name, value, "distribution", options);
+  }
+  /**
+   * Time a function execution and record as distribution
+   */
+  async time(name, fn, options) {
+    const start = Date.now();
+    try {
+      const result = await fn();
+      this.distribution(name, Date.now() - start, { ...options, unit: options?.unit || "ms" });
+      return result;
+    } catch (err) {
+      this.distribution(name, Date.now() - start, {
+        ...options,
+        unit: options?.unit || "ms",
+        tags: { ...options?.tags, error: "true" }
+      });
+      throw err;
+    }
+  }
+  /**
+   * Create a timer that records on stop
+   */
+  startTimer(name, options) {
+    const start = Date.now();
+    return {
+      stop: () => {
+        this.distribution(name, Date.now() - start, { ...options, unit: options?.unit || "ms" });
+      }
+    };
+  }
+  /**
+   * Force flush all queued metrics
+   */
+  async flush() {
+    if (this.queue.length === 0) return;
+    const metrics = [...this.queue];
+    this.queue = [];
+    try {
+      const response = await fetch(`${this.endpoint}/api/sdk/metrics`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.apiKey
+        },
+        body: JSON.stringify({ metrics })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      this.log(`Flushed ${metrics.length} metrics`);
+    } catch (err) {
+      this.queue.unshift(...metrics);
+      this.log("Failed to flush metrics:", err);
+    }
+  }
+  /**
+   * Stop the flush timer and flush remaining metrics
+   */
+  async destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  enqueue(name, value, type, options) {
+    this.queue.push({
+      name,
+      value,
+      type,
+      unit: options?.unit,
+      tags: options?.tags,
+      timestamp: options?.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (this.queue.length >= this.maxBatchSize) {
+      this.flush();
+    }
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+    if (typeof window !== "undefined") {
+      window.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden") {
+          this.flushWithBeacon();
+        }
+      });
+    }
+  }
+  flushWithBeacon() {
+    if (this.queue.length === 0 || typeof navigator?.sendBeacon !== "function") return;
+    const metrics = [...this.queue];
+    this.queue = [];
+    const blob = new Blob(
+      [JSON.stringify({ metrics, apiKey: this.apiKey })],
+      { type: "application/json" }
+    );
+    navigator.sendBeacon(`${this.endpoint}/api/sdk/metrics`, blob);
+    this.log(`Flushed ${metrics.length} metrics via beacon`);
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[SitePong:Metrics]", ...args);
+    }
+  }
+};
+
+// src/database.ts
+var DatabaseTracker = class {
+  constructor(config) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.queryCounter = 0;
+    this.nPlusOneDetector = /* @__PURE__ */ new Map();
+    this.config = {
+      slowQueryThreshold: 1e3,
+      maxBatchSize: 50,
+      flushInterval: 1e4,
+      redactParams: true,
+      ...config
+    };
+    this.startFlushTimer();
+  }
+  /**
+   * Track a database query execution
+   */
+  async track(query, fn, source) {
+    const start = Date.now();
+    this.queryCounter++;
+    try {
+      const result = await fn();
+      const duration_ms = Date.now() - start;
+      this.recordQuery({
+        query: this.config.redactParams ? this.redactQuery(query) : query,
+        duration_ms,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source,
+        is_slow: duration_ms >= (this.config.slowQueryThreshold || 1e3)
+      });
+      this.detectNPlusOne(query);
+      return result;
+    } catch (err) {
+      const duration_ms = Date.now() - start;
+      this.recordQuery({
+        query: this.config.redactParams ? this.redactQuery(query) : query,
+        duration_ms,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+  }
+  /**
+   * Track a synchronous database query
+   */
+  trackSync(query, fn, source) {
+    const start = Date.now();
+    this.queryCounter++;
+    try {
+      const result = fn();
+      const duration_ms = Date.now() - start;
+      this.recordQuery({
+        query: this.config.redactParams ? this.redactQuery(query) : query,
+        duration_ms,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source,
+        is_slow: duration_ms >= (this.config.slowQueryThreshold || 1e3)
+      });
+      return result;
+    } catch (err) {
+      const duration_ms = Date.now() - start;
+      this.recordQuery({
+        query: this.config.redactParams ? this.redactQuery(query) : query,
+        duration_ms,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+  }
+  /**
+   * Get current query count (useful for N+1 detection in tests)
+   */
+  getQueryCount() {
+    return this.queryCounter;
+  }
+  /**
+   * Reset the query counter
+   */
+  resetQueryCount() {
+    this.queryCounter = 0;
+    this.nPlusOneDetector.clear();
+  }
+  /**
+   * Get detected N+1 patterns
+   */
+  getNPlusOnePatterns() {
+    const patterns = [];
+    for (const [query, { count }] of this.nPlusOneDetector.entries()) {
+      if (count >= 5) {
+        patterns.push({ query, count });
+      }
+    }
+    return patterns;
+  }
+  /**
+   * Force flush queued query events
+   */
+  async flush() {
+    if (this.queue.length === 0) return;
+    const queries = [...this.queue];
+    this.queue = [];
+    try {
+      const response = await fetch(`${this.config.endpoint}/api/sdk/metrics`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        },
+        body: JSON.stringify({
+          metrics: queries.map((q) => ({
+            name: "db.query",
+            value: q.duration_ms,
+            type: "distribution",
+            unit: "ms",
+            tags: {
+              query: q.query.substring(0, 200),
+              source: q.source || "unknown",
+              is_slow: String(q.is_slow || false),
+              ...q.error ? { error: "true" } : {}
+            },
+            timestamp: q.timestamp
+          }))
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      this.log(`Flushed ${queries.length} query events`);
+    } catch (err) {
+      this.queue.unshift(...queries);
+      this.log("Failed to flush query events:", err);
+    }
+  }
+  /**
+   * Destroy the tracker and flush remaining events
+   */
+  async destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  recordQuery(event) {
+    this.queue.push(event);
+    if (this.queue.length >= (this.config.maxBatchSize || 50)) {
+      this.flush();
+    }
+    if (event.is_slow) {
+      this.log(`Slow query (${event.duration_ms}ms):`, event.query.substring(0, 100));
+    }
+  }
+  detectNPlusOne(query) {
+    const pattern = this.normalizeQuery(query);
+    const now = Date.now();
+    const existing = this.nPlusOneDetector.get(pattern);
+    if (existing) {
+      if (now - existing.since < 1e3) {
+        existing.count++;
+        if (existing.count === 5) {
+          this.log(`N+1 query detected! Pattern repeated ${existing.count} times:`, pattern.substring(0, 100));
+        }
+      } else {
+        this.nPlusOneDetector.set(pattern, { count: 1, since: now });
+      }
+    } else {
+      this.nPlusOneDetector.set(pattern, { count: 1, since: now });
+    }
+    if (this.nPlusOneDetector.size > 100) {
+      const entries = [...this.nPlusOneDetector.entries()];
+      entries.sort((a, b) => a[1].since - b[1].since);
+      for (let i = 0; i < 50; i++) {
+        this.nPlusOneDetector.delete(entries[i][0]);
+      }
+    }
+  }
+  normalizeQuery(query) {
+    return query.replace(/\s+/g, " ").replace(/'[^']*'/g, "?").replace(/\b\d+\b/g, "?").trim().substring(0, 300);
+  }
+  redactQuery(query) {
+    return query.replace(/'[^']*'/g, "'***'").replace(/\b\d{4,}\b/g, "***");
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.config.flushInterval || 1e4);
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong:DB]", ...args);
+    }
+  }
+};
+
+// src/profiling.ts
+var Profiler = class {
+  constructor(config) {
+    this.profiles = [];
+    this.activeProfile = null;
+    this.frameStack = [];
+    this.flushTimer = null;
+    this.config = {
+      sampleRate: 0.1,
+      maxDuration: 3e4,
+      flushInterval: 3e4,
+      ...config
+    };
+    this.startFlushTimer();
+  }
+  /**
+   * Profile an async function execution
+   */
+  async profile(name, fn, metadata) {
+    if (Math.random() > (this.config.sampleRate || 0.1)) {
+      return fn();
+    }
+    const profileId = this.generateId();
+    const startTime = performance.now();
+    this.activeProfile = {
+      id: profileId,
+      name,
+      startTime,
+      duration_ms: 0,
+      frames: [],
+      metadata
+    };
+    this.frameStack = [];
+    const rootFrame = {
+      name,
+      start_ms: 0,
+      duration_ms: 0,
+      children: [],
+      metadata
+    };
+    this.frameStack.push(rootFrame);
+    try {
+      const result = await fn();
+      rootFrame.duration_ms = performance.now() - startTime;
+      this.activeProfile.duration_ms = rootFrame.duration_ms;
+      this.activeProfile.frames = [rootFrame];
+      if (rootFrame.duration_ms <= (this.config.maxDuration || 3e4)) {
+        this.profiles.push(this.activeProfile);
+      }
+      this.activeProfile = null;
+      this.frameStack = [];
+      return result;
+    } catch (err) {
+      rootFrame.duration_ms = performance.now() - startTime;
+      rootFrame.metadata = { ...rootFrame.metadata, error: true };
+      if (this.activeProfile) {
+        this.activeProfile.duration_ms = rootFrame.duration_ms;
+        this.activeProfile.frames = [rootFrame];
+        this.profiles.push(this.activeProfile);
+      }
+      this.activeProfile = null;
+      this.frameStack = [];
+      throw err;
+    }
+  }
+  /**
+   * Start a profiling span within an active profile
+   */
+  startSpan(name, metadata) {
+    if (!this.activeProfile) return () => {
+    };
+    const startMs = performance.now() - this.activeProfile.startTime;
+    const frame = {
+      name,
+      start_ms: startMs,
+      duration_ms: 0,
+      children: [],
+      metadata
+    };
+    const parent = this.frameStack[this.frameStack.length - 1];
+    if (parent) {
+      parent.children.push(frame);
+    }
+    this.frameStack.push(frame);
+    return () => {
+      frame.duration_ms = performance.now() - this.activeProfile.startTime - frame.start_ms;
+      this.frameStack.pop();
+    };
+  }
+  /**
+   * Get all collected profiles
+   */
+  getProfiles() {
+    return [...this.profiles];
+  }
+  /**
+   * Get the latest profile
+   */
+  getLatestProfile() {
+    return this.profiles.length > 0 ? this.profiles[this.profiles.length - 1] : null;
+  }
+  /**
+   * Flush profiles to the server
+   */
+  async flush() {
+    if (this.profiles.length === 0) return;
+    const profiles = [...this.profiles];
+    this.profiles = [];
+    try {
+      const response = await fetch(`${this.config.endpoint}/api/sdk/metrics`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        },
+        body: JSON.stringify({
+          metrics: profiles.map((p) => ({
+            name: `profile.${p.name}`,
+            value: p.duration_ms,
+            type: "distribution",
+            unit: "ms",
+            tags: {
+              profile_id: p.id,
+              frame_count: String(countFrames(p.frames)),
+              ...p.metadata || {}
+            },
+            timestamp: new Date(Date.now() - p.duration_ms).toISOString()
+          }))
+        })
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      this.log(`Flushed ${profiles.length} profiles`);
+    } catch (err) {
+      this.profiles.unshift(...profiles);
+      this.log("Failed to flush profiles:", err);
+    }
+  }
+  /**
+   * Destroy the profiler
+   */
+  async destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.config.flushInterval || 3e4);
+  }
+  generateId() {
+    return `prof_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SitePong:Profiler]", ...args);
+    }
+  }
+};
+function countFrames(frames) {
+  let count = frames.length;
+  for (const frame of frames) {
+    count += countFrames(frame.children);
+  }
+  return count;
+}
+
 // src/index.ts
-var DEFAULT_ENDPOINT = "https://ingest.sitepong.com";
-var DEFAULT_BATCH_SIZE = 10;
-var DEFAULT_FLUSH_INTERVAL = 5e3;
+var DEFAULT_ENDPOINT6 = "https://ingest.sitepong.com";
+var DEFAULT_BATCH_SIZE2 = 10;
+var DEFAULT_FLUSH_INTERVAL4 = 5e3;
 var SitePongClient = class {
   constructor() {
     this.errorQueue = [];
     this.flushTimer = null;
     this.context = {};
     this.initialized = false;
+    this.flagManager = null;
+    this.analyticsManager = null;
+    this.fingerprintManager = null;
+    this.replayManager = null;
+    this.performanceManager = null;
+    this.cronManager = null;
+    this.metricsManager = null;
+    this.databaseTracker = null;
+    this.profiler = null;
     this.config = {
       apiKey: "",
-      endpoint: DEFAULT_ENDPOINT,
+      endpoint: DEFAULT_ENDPOINT6,
       environment: "production",
       release: "",
       autoCapture: true,
-      maxBatchSize: DEFAULT_BATCH_SIZE,
-      flushInterval: DEFAULT_FLUSH_INTERVAL,
+      maxBatchSize: DEFAULT_BATCH_SIZE2,
+      flushInterval: DEFAULT_FLUSH_INTERVAL4,
       debug: false
     };
   }
@@ -34,12 +4056,389 @@ var SitePongClient = class {
     }
     this.startFlushTimer();
     this.log("Initialized with endpoint:", this.config.endpoint);
+    if (config.enableFlags) {
+      this.flagManager = new FlagManager({
+        apiKey: config.apiKey,
+        endpoint: config.flagsEndpoint || config.endpoint || DEFAULT_ENDPOINT6,
+        debug: config.debug
+      });
+      this.flagManager.init().catch((err) => {
+        this.log("Failed to initialize flags:", err);
+      });
+    }
+    if (config.analytics?.enabled) {
+      if (this.analyticsManager) {
+        this.analyticsManager.destroy();
+      }
+      this.analyticsManager = new AnalyticsManager({
+        apiKey: config.apiKey,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT6,
+        enabled: true,
+        autocapturePageviews: config.analytics.autocapturePageviews,
+        autocaptureClicks: config.analytics.autocaptureClicks,
+        autocaptureForms: config.analytics.autocaptureForms,
+        autocapture: config.analytics.autocapture,
+        maxBatchSize: config.analytics.maxBatchSize,
+        flushInterval: config.analytics.flushInterval,
+        eventsEndpoint: config.analytics.eventsEndpoint,
+        debug: config.debug
+      });
+      this.analyticsManager.init();
+    }
+    if (config.fingerprint?.enabled) {
+      this.fingerprintManager = new FingerprintManager({
+        apiKey: config.apiKey,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT6,
+        enabled: true,
+        extendedSignals: config.fingerprint.extendedSignals,
+        visitorEndpoint: config.fingerprint.visitorEndpoint,
+        debug: config.debug
+      });
+    }
+    if (config.performance?.enabled) {
+      if (this.performanceManager) {
+        this.performanceManager.destroy();
+      }
+      this.performanceManager = new PerformanceManager({
+        apiKey: config.apiKey,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT6,
+        enabled: true,
+        webVitals: config.performance.webVitals,
+        navigationTiming: config.performance.navigationTiming,
+        resourceTiming: config.performance.resourceTiming,
+        sampleRate: config.performance.sampleRate,
+        flushInterval: config.performance.flushInterval,
+        performanceEndpoint: config.performance.performanceEndpoint,
+        debug: config.debug
+      });
+      this.performanceManager.init();
+    }
+    if (config.replay?.enabled) {
+      if (this.replayManager) {
+        this.replayManager.stop();
+      }
+      this.replayManager = new ReplayManager({
+        apiKey: config.apiKey,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT6,
+        enabled: true,
+        maskInputs: config.replay.maskInputs,
+        blockSelector: config.replay.blockSelector,
+        maskSelector: config.replay.maskSelector,
+        sampleRate: config.replay.sampleRate,
+        maxSessionDuration: config.replay.maxSessionDuration,
+        flushInterval: config.replay.flushInterval,
+        replayEndpoint: config.replay.replayEndpoint,
+        recordNetwork: config.replay.recordNetwork,
+        captureNetworkHeaders: config.replay.captureNetworkHeaders,
+        recordConsole: config.replay.recordConsole,
+        consoleLevels: config.replay.consoleLevels,
+        debug: config.debug
+      });
+      this.replayManager.start();
+    }
+    if (config.crons?.enabled) {
+      this.cronManager = new CronMonitorManager({
+        apiKey: config.apiKey,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT6,
+        debug: config.debug
+      });
+    }
+    if (config.database?.enabled) {
+      this.databaseTracker = new DatabaseTracker({
+        apiKey: config.apiKey,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT6,
+        debug: config.debug,
+        slowQueryThreshold: config.database.slowQueryThreshold,
+        redactParams: config.database.redactParams
+      });
+    }
+    if (config.metrics?.enabled) {
+      this.metricsManager = new MetricsManager({
+        apiKey: config.apiKey,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT6,
+        debug: config.debug,
+        flushInterval: config.metrics.flushInterval,
+        maxBatchSize: config.metrics.maxBatchSize
+      });
+    }
+    if (config.profiling?.enabled) {
+      this.profiler = new Profiler({
+        apiKey: config.apiKey,
+        endpoint: config.endpoint || DEFAULT_ENDPOINT6,
+        debug: config.debug,
+        sampleRate: config.profiling.sampleRate,
+        maxDuration: config.profiling.maxDuration,
+        flushInterval: config.profiling.flushInterval
+      });
+    }
+  }
+  /**
+   * Get a feature flag value
+   * Returns the cached evaluated result or default value
+   */
+  getFlag(key, defaultValue = false) {
+    if (!this.flagManager) {
+      this.log("Flags not enabled. Set enableFlags: true in init()");
+      return defaultValue;
+    }
+    return this.flagManager.getFlag(key, defaultValue);
+  }
+  /**
+   * Get all feature flag values
+   */
+  getAllFlags() {
+    if (!this.flagManager) {
+      return {};
+    }
+    return this.flagManager.getAllFlags();
+  }
+  /**
+   * Wait for flags to be initialized
+   */
+  async waitForFlags() {
+    if (!this.flagManager) {
+      return;
+    }
+    await this.flagManager.waitForInit();
+  }
+  /**
+   * Check if flags are ready
+   */
+  areFlagsReady() {
+    return this.flagManager?.isInitialized() ?? false;
+  }
+  /**
+   * Get a multivariate flag variant
+   * Returns the assigned variant key or the default value
+   */
+  getVariant(key, defaultValue = null) {
+    if (!this.flagManager) {
+      this.log("Flags not enabled. Set enableFlags: true in init()");
+      return defaultValue;
+    }
+    return this.flagManager.getVariant(key, defaultValue);
+  }
+  /**
+   * Get the payload for a multivariate flag's assigned variant
+   */
+  getVariantPayload(key, defaultValue = null) {
+    if (!this.flagManager) {
+      return defaultValue;
+    }
+    return this.flagManager.getVariantPayload(key, defaultValue);
+  }
+  /**
+   * Force refresh flags from the server
+   */
+  async refreshFlags() {
+    if (!this.flagManager) {
+      return;
+    }
+    await this.flagManager.refresh();
+  }
+  // --- Analytics (Tier 4) ---
+  track(eventName, properties) {
+    if (!this.analyticsManager) {
+      this.log("Analytics not enabled. Set analytics.enabled: true in init()");
+      return;
+    }
+    this.analyticsManager.track(eventName, properties);
+  }
+  trackPageView(url, properties) {
+    if (!this.analyticsManager) {
+      this.log("Analytics not enabled. Set analytics.enabled: true in init()");
+      return;
+    }
+    this.analyticsManager.trackPageView(url, properties);
+  }
+  identify(userId, traits) {
+    if (this.replayManager) {
+      this.replayManager.setUser({ id: userId });
+    }
+    if (!this.analyticsManager) {
+      this.log("Analytics not enabled. Set analytics.enabled: true in init()");
+      return;
+    }
+    this.analyticsManager.identify(userId, traits);
+  }
+  group(groupId, traits) {
+    if (!this.analyticsManager) {
+      this.log("Analytics not enabled. Set analytics.enabled: true in init()");
+      return;
+    }
+    this.analyticsManager.group(groupId, traits);
+  }
+  resetAnalytics() {
+    if (!this.analyticsManager) {
+      return;
+    }
+    this.analyticsManager.reset();
+  }
+  // --- Fingerprint (Tier 5) ---
+  async getVisitorId() {
+    if (!this.fingerprintManager) {
+      throw new Error("Fingerprint not enabled. Set fingerprint.enabled: true in init()");
+    }
+    return this.fingerprintManager.getVisitorId();
+  }
+  async getDeviceSignals() {
+    if (!this.fingerprintManager) {
+      throw new Error("Fingerprint not enabled. Set fingerprint.enabled: true in init()");
+    }
+    return this.fingerprintManager.getDeviceSignals();
+  }
+  async getFraudCheck() {
+    if (!this.fingerprintManager) {
+      throw new Error("Fingerprint not enabled. Set fingerprint.enabled: true in init()");
+    }
+    return this.fingerprintManager.getFraudCheck();
+  }
+  // --- Session Replay (Tier 6) ---
+  startReplay() {
+    if (!this.replayManager) {
+      this.log("Replay not enabled. Set replay.enabled: true in init()");
+      return false;
+    }
+    return this.replayManager.start();
+  }
+  stopReplay() {
+    if (!this.replayManager) return;
+    this.replayManager.stop();
+  }
+  isReplayRecording() {
+    return this.replayManager?.isRecording() ?? false;
+  }
+  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);
+  }
+  endTransaction(id, status = "ok") {
+    if (!this.performanceManager) return;
+    this.performanceManager.endTransaction(id, status);
+  }
+  startSpan(transactionId, name, data) {
+    if (!this.performanceManager) return "";
+    return this.performanceManager.startSpan(transactionId, name, data);
+  }
+  endSpan(transactionId, spanId, status = "ok") {
+    if (!this.performanceManager) return;
+    this.performanceManager.endSpan(transactionId, spanId, status);
+  }
+  getWebVitals() {
+    if (!this.performanceManager) return {};
+    return this.performanceManager.getVitals();
+  }
+  // --- Cron Monitor methods ---
+  cronCheckin(slug, options) {
+    if (!this.cronManager) {
+      this.log("Cron monitoring not enabled. Set crons.enabled: true in init()");
+      return Promise.resolve();
+    }
+    return this.cronManager.checkin(slug, options);
+  }
+  cronStart(slug, environment) {
+    if (!this.cronManager) {
+      this.log("Cron monitoring not enabled. Set crons.enabled: true in init()");
+      return { ok: () => Promise.resolve(), error: () => Promise.resolve() };
+    }
+    return this.cronManager.start(slug, environment);
+  }
+  cronWrap(slug, fn, environment) {
+    if (!this.cronManager) {
+      return fn();
+    }
+    return this.cronManager.wrap(slug, fn, environment);
+  }
+  // --- Custom Metrics methods ---
+  metricIncrement(name, value, options) {
+    if (!this.metricsManager) {
+      this.log("Metrics not enabled. Set metrics.enabled: true in init()");
+      return;
+    }
+    this.metricsManager.increment(name, value, options);
+  }
+  metricGauge(name, value, options) {
+    if (!this.metricsManager) return;
+    this.metricsManager.gauge(name, value, options);
+  }
+  metricHistogram(name, value, options) {
+    if (!this.metricsManager) return;
+    this.metricsManager.histogram(name, value, options);
+  }
+  metricDistribution(name, value, options) {
+    if (!this.metricsManager) return;
+    this.metricsManager.distribution(name, value, options);
+  }
+  async metricTime(name, fn, options) {
+    if (!this.metricsManager) return fn();
+    return this.metricsManager.time(name, fn, options);
+  }
+  metricStartTimer(name, options) {
+    if (!this.metricsManager) return { stop: () => {
+    } };
+    return this.metricsManager.startTimer(name, options);
+  }
+  async flushMetrics() {
+    if (!this.metricsManager) return;
+    return this.metricsManager.flush();
+  }
+  // --- Database Query Tracking methods ---
+  async dbTrack(query, fn, source) {
+    if (!this.databaseTracker) return fn();
+    return this.databaseTracker.track(query, fn, source);
+  }
+  dbTrackSync(query, fn, source) {
+    if (!this.databaseTracker) return fn();
+    return this.databaseTracker.trackSync(query, fn, source);
+  }
+  getDbQueryCount() {
+    if (!this.databaseTracker) return 0;
+    return this.databaseTracker.getQueryCount();
+  }
+  resetDbQueryCount() {
+    if (this.databaseTracker) this.databaseTracker.resetQueryCount();
+  }
+  getDbNPlusOnePatterns() {
+    if (!this.databaseTracker) return [];
+    return this.databaseTracker.getNPlusOnePatterns();
+  }
+  // --- Profiling methods ---
+  async profile(name, fn, metadata) {
+    if (!this.profiler) return fn();
+    return this.profiler.profile(name, fn, metadata);
+  }
+  startProfileSpan(name, metadata) {
+    if (!this.profiler) return () => {
+    };
+    return this.profiler.startSpan(name, metadata);
+  }
+  getProfiles() {
+    if (!this.profiler) return [];
+    return this.profiler.getProfiles();
+  }
+  getLatestProfile() {
+    if (!this.profiler) return null;
+    return this.profiler.getLatestProfile();
+  }
+  async flushProfiles() {
+    if (!this.profiler) return;
+    return this.profiler.flush();
   }
   setContext(context) {
     this.context = { ...this.context, ...context };
   }
   setUser(user) {
     this.context.user = user;
+    if (this.replayManager) {
+      this.replayManager.setUser(user ? { id: user.id } : null);
+    }
   }
   setTags(tags) {
     this.context.tags = { ...this.context.tags, ...tags };
@@ -69,7 +4468,8 @@ var SitePongClient = class {
       userAgent: this.getUserAgent(),
       environment: this.config.environment,
       release: this.config.release,
-      context: { ...this.context, ...additionalContext }
+      context: { ...this.context, ...additionalContext },
+      replaySessionId: this.replayManager?.isRecording() ? this.replayManager.getSessionId() || void 0 : void 0
     };
     this.errorQueue.push(capturedError);
     this.log("Captured message:", message);
@@ -104,7 +4504,7 @@ var SitePongClient = class {
   formatError(error, additionalContext) {
     const isError = error instanceof Error;
     const message = isError ? error.message : String(error);
-    const stack = isError ? error.stack : void 0;
+    const stack = isError ? error.stack : new Error(message).stack;
     const type = isError ? error.name : "Error";
     return {
       message,
@@ -116,7 +4516,8 @@ var SitePongClient = class {
       environment: this.config.environment,
       release: this.config.release,
       context: { ...this.context, ...additionalContext },
-      fingerprint: this.generateFingerprint(message, stack)
+      fingerprint: this.generateFingerprint(message, stack),
+      replaySessionId: this.replayManager?.isRecording() ? this.replayManager.getSessionId() || void 0 : void 0
     };
   }
   generateFingerprint(message, stack) {
@@ -207,8 +4608,52 @@ var setContext = sitepong.setContext.bind(sitepong);
 var setUser = sitepong.setUser.bind(sitepong);
 var setTags = sitepong.setTags.bind(sitepong);
 var flush = sitepong.flush.bind(sitepong);
+var getFlag = sitepong.getFlag.bind(sitepong);
+var getAllFlags = sitepong.getAllFlags.bind(sitepong);
+var getVariant = sitepong.getVariant.bind(sitepong);
+var getVariantPayload2 = sitepong.getVariantPayload.bind(sitepong);
+var waitForFlags = sitepong.waitForFlags.bind(sitepong);
+var areFlagsReady = sitepong.areFlagsReady.bind(sitepong);
+var refreshFlags = sitepong.refreshFlags.bind(sitepong);
+var track = sitepong.track.bind(sitepong);
+var trackPageView = sitepong.trackPageView.bind(sitepong);
+var identify = sitepong.identify.bind(sitepong);
+var group = sitepong.group.bind(sitepong);
+var resetAnalytics = sitepong.resetAnalytics.bind(sitepong);
+var getVisitorId = sitepong.getVisitorId.bind(sitepong);
+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 isReplayRecording = sitepong.isReplayRecording.bind(sitepong);
+var getReplaySessionId = sitepong.getReplaySessionId.bind(sitepong);
+var startTransaction = sitepong.startTransaction.bind(sitepong);
+var endTransaction = sitepong.endTransaction.bind(sitepong);
+var startSpan = sitepong.startSpan.bind(sitepong);
+var endSpan = sitepong.endSpan.bind(sitepong);
+var getWebVitals = sitepong.getWebVitals.bind(sitepong);
+var dbTrack = sitepong.dbTrack.bind(sitepong);
+var dbTrackSync = sitepong.dbTrackSync.bind(sitepong);
+var getDbQueryCount = sitepong.getDbQueryCount.bind(sitepong);
+var resetDbQueryCount = sitepong.resetDbQueryCount.bind(sitepong);
+var getDbNPlusOnePatterns = sitepong.getDbNPlusOnePatterns.bind(sitepong);
+var cronCheckin = sitepong.cronCheckin.bind(sitepong);
+var cronStart = sitepong.cronStart.bind(sitepong);
+var cronWrap = sitepong.cronWrap.bind(sitepong);
+var metricIncrement = sitepong.metricIncrement.bind(sitepong);
+var metricGauge = sitepong.metricGauge.bind(sitepong);
+var metricHistogram = sitepong.metricHistogram.bind(sitepong);
+var metricDistribution = sitepong.metricDistribution.bind(sitepong);
+var metricTime = sitepong.metricTime.bind(sitepong);
+var metricStartTimer = sitepong.metricStartTimer.bind(sitepong);
+var flushMetrics = sitepong.flushMetrics.bind(sitepong);
+var profile = sitepong.profile.bind(sitepong);
+var startProfileSpan = sitepong.startProfileSpan.bind(sitepong);
+var getProfiles = sitepong.getProfiles.bind(sitepong);
+var getLatestProfile = sitepong.getLatestProfile.bind(sitepong);
+var flushProfiles = sitepong.flushProfiles.bind(sitepong);
 var index_default = sitepong;
 
-export { captureError, captureMessage, index_default as default, flush, init, setContext, setTags, setUser };
+export { TracePropagator, areFlagsReady, captureError, captureMessage, clearAnonymousId, createTraceContext, cronCheckin, cronStart, cronWrap, dbTrack, dbTrackSync, index_default as default, endSpan, endTransaction, extractTrace, flush, flushMetrics, flushProfiles, generateSpanId, generateTraceId, getAllFlags, getAnonymousId, getDbNPlusOnePatterns, getDbQueryCount, getDeviceSignals, getFlag, getFraudCheck, getLatestProfile, getProfiles, getReplaySessionId, getVariant, getVariantPayload2 as getVariantPayload, getVisitorId, getWebVitals, group, identify, init, isReplayRecording, metricDistribution, metricGauge, metricHistogram, metricIncrement, metricStartTimer, metricTime, profile, propagateTrace, refreshFlags, resetAnalytics, resetDbQueryCount, setAnonymousId, setContext, setTags, setUser, startProfileSpan, startReplay, startSpan, startTransaction, stopReplay, track, trackPageView, waitForFlags };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map