sitepong 0.0.1 → 0.0.5

package/dist/index.js

@@ -2,24 +2,4046 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+// 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
     };
   }
@@ -38,12 +4060,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 };
@@ -73,7 +4472,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);
@@ -108,7 +4508,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,
@@ -120,7 +4520,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) {
@@ -211,15 +4612,112 @@ 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;
 
+exports.TracePropagator = TracePropagator;
+exports.areFlagsReady = areFlagsReady;
 exports.captureError = captureError;
 exports.captureMessage = captureMessage;
+exports.clearAnonymousId = clearAnonymousId;
+exports.createTraceContext = createTraceContext;
+exports.cronCheckin = cronCheckin;
+exports.cronStart = cronStart;
+exports.cronWrap = cronWrap;
+exports.dbTrack = dbTrack;
+exports.dbTrackSync = dbTrackSync;
 exports.default = index_default;
+exports.endSpan = endSpan;
+exports.endTransaction = endTransaction;
+exports.extractTrace = extractTrace;
 exports.flush = flush;
+exports.flushMetrics = flushMetrics;
+exports.flushProfiles = flushProfiles;
+exports.generateSpanId = generateSpanId;
+exports.generateTraceId = generateTraceId;
+exports.getAllFlags = getAllFlags;
+exports.getAnonymousId = getAnonymousId;
+exports.getDbNPlusOnePatterns = getDbNPlusOnePatterns;
+exports.getDbQueryCount = getDbQueryCount;
+exports.getDeviceSignals = getDeviceSignals;
+exports.getFlag = getFlag;
+exports.getFraudCheck = getFraudCheck;
+exports.getLatestProfile = getLatestProfile;
+exports.getProfiles = getProfiles;
+exports.getReplaySessionId = getReplaySessionId;
+exports.getVariant = getVariant;
+exports.getVariantPayload = getVariantPayload2;
+exports.getVisitorId = getVisitorId;
+exports.getWebVitals = getWebVitals;
+exports.group = group;
+exports.identify = identify;
 exports.init = init;
+exports.isReplayRecording = isReplayRecording;
+exports.metricDistribution = metricDistribution;
+exports.metricGauge = metricGauge;
+exports.metricHistogram = metricHistogram;
+exports.metricIncrement = metricIncrement;
+exports.metricStartTimer = metricStartTimer;
+exports.metricTime = metricTime;
+exports.profile = profile;
+exports.propagateTrace = propagateTrace;
+exports.refreshFlags = refreshFlags;
+exports.resetAnalytics = resetAnalytics;
+exports.resetDbQueryCount = resetDbQueryCount;
+exports.setAnonymousId = setAnonymousId;
 exports.setContext = setContext;
 exports.setTags = setTags;
 exports.setUser = setUser;
+exports.startProfileSpan = startProfileSpan;
+exports.startReplay = startReplay;
+exports.startSpan = startSpan;
+exports.startTransaction = startTransaction;
+exports.stopReplay = stopReplay;
+exports.track = track;
+exports.trackPageView = trackPageView;
+exports.waitForFlags = waitForFlags;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map