@loamly/tracker 1.9.0 → 2.0.0

package/dist/index.cjs

@@ -34,7 +34,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/config.ts
-var VERSION = "1.9.0";
+var VERSION = "2.0.0";
 var DEFAULT_CONFIG = {
   apiHost: "https://app.loamly.ai",
   endpoints: {
@@ -672,6 +672,1025 @@ var FocusBlurAnalyzer = class {
   }
 };
 
+// src/detection/agentic-browser.ts
+var CometDetector = class {
+  constructor() {
+    this.detected = false;
+    this.checkComplete = false;
+    this.observer = null;
+  }
+  /**
+   * Initialize detection
+   * @param timeout - Max time to observe for Comet DOM (default: 5s)
+   */
+  init(timeout = 5e3) {
+    if (typeof document === "undefined") return;
+    this.check();
+    if (!this.detected && document.body) {
+      this.observer = new MutationObserver(() => this.check());
+      this.observer.observe(document.body, { childList: true, subtree: true });
+      setTimeout(() => {
+        if (this.observer && !this.detected) {
+          this.observer.disconnect();
+          this.observer = null;
+          this.checkComplete = true;
+        }
+      }, timeout);
+    }
+  }
+  check() {
+    if (document.querySelector(".pplx-agent-overlay-stop-button")) {
+      this.detected = true;
+      this.checkComplete = true;
+      if (this.observer) {
+        this.observer.disconnect();
+        this.observer = null;
+      }
+    }
+  }
+  isDetected() {
+    return this.detected;
+  }
+  isCheckComplete() {
+    return this.checkComplete;
+  }
+  destroy() {
+    if (this.observer) {
+      this.observer.disconnect();
+      this.observer = null;
+    }
+  }
+};
+var MouseAnalyzer = class {
+  /**
+   * @param teleportThreshold - Distance in pixels to consider a teleport (default: 500)
+   */
+  constructor(teleportThreshold = 500) {
+    this.lastX = -1;
+    this.lastY = -1;
+    this.teleportingClicks = 0;
+    this.totalMovements = 0;
+    this.handleMove = (e) => {
+      this.totalMovements++;
+      this.lastX = e.clientX;
+      this.lastY = e.clientY;
+    };
+    this.handleClick = (e) => {
+      if (this.lastX !== -1 && this.lastY !== -1) {
+        const dx = Math.abs(e.clientX - this.lastX);
+        const dy = Math.abs(e.clientY - this.lastY);
+        if (dx > this.teleportThreshold || dy > this.teleportThreshold) {
+          this.teleportingClicks++;
+        }
+      }
+      this.lastX = e.clientX;
+      this.lastY = e.clientY;
+    };
+    this.teleportThreshold = teleportThreshold;
+  }
+  /**
+   * Initialize mouse tracking
+   */
+  init() {
+    if (typeof document === "undefined") return;
+    document.addEventListener("mousemove", this.handleMove, { passive: true });
+    document.addEventListener("mousedown", this.handleClick, { passive: true });
+  }
+  getPatterns() {
+    return {
+      teleportingClicks: this.teleportingClicks,
+      totalMovements: this.totalMovements
+    };
+  }
+  destroy() {
+    if (typeof document === "undefined") return;
+    document.removeEventListener("mousemove", this.handleMove);
+    document.removeEventListener("mousedown", this.handleClick);
+  }
+};
+var CDPDetector = class {
+  constructor() {
+    this.detected = false;
+  }
+  /**
+   * Run detection checks
+   */
+  detect() {
+    if (typeof navigator === "undefined") return false;
+    if (navigator.webdriver) {
+      this.detected = true;
+      return true;
+    }
+    if (typeof window !== "undefined") {
+      const win = window;
+      const automationProps = [
+        "__webdriver_evaluate",
+        "__selenium_evaluate",
+        "__webdriver_script_function",
+        "__webdriver_script_func",
+        "__webdriver_script_fn",
+        "__fxdriver_evaluate",
+        "__driver_unwrapped",
+        "__webdriver_unwrapped",
+        "__driver_evaluate",
+        "__selenium_unwrapped",
+        "__fxdriver_unwrapped"
+      ];
+      for (const prop of automationProps) {
+        if (prop in win) {
+          this.detected = true;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  isDetected() {
+    return this.detected;
+  }
+};
+var AgenticBrowserAnalyzer = class {
+  constructor() {
+    this.initialized = false;
+    this.cometDetector = new CometDetector();
+    this.mouseAnalyzer = new MouseAnalyzer();
+    this.cdpDetector = new CDPDetector();
+  }
+  /**
+   * Initialize all detectors
+   */
+  init() {
+    if (this.initialized) return;
+    this.initialized = true;
+    this.cometDetector.init();
+    this.mouseAnalyzer.init();
+    this.cdpDetector.detect();
+  }
+  /**
+   * Get current detection result
+   */
+  getResult() {
+    const signals = [];
+    let probability = 0;
+    if (this.cometDetector.isDetected()) {
+      signals.push("comet_dom_detected");
+      probability = Math.max(probability, 0.85);
+    }
+    if (this.cdpDetector.isDetected()) {
+      signals.push("cdp_detected");
+      probability = Math.max(probability, 0.92);
+    }
+    const mousePatterns = this.mouseAnalyzer.getPatterns();
+    if (mousePatterns.teleportingClicks > 0) {
+      signals.push(`teleporting_clicks:${mousePatterns.teleportingClicks}`);
+      probability = Math.max(probability, 0.78);
+    }
+    return {
+      cometDOMDetected: this.cometDetector.isDetected(),
+      cdpDetected: this.cdpDetector.isDetected(),
+      mousePatterns,
+      agenticProbability: probability,
+      signals
+    };
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.cometDetector.destroy();
+    this.mouseAnalyzer.destroy();
+  }
+};
+function createAgenticAnalyzer() {
+  const analyzer = new AgenticBrowserAnalyzer();
+  if (typeof document !== "undefined") {
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => analyzer.init());
+    } else {
+      analyzer.init();
+    }
+  }
+  return analyzer;
+}
+
+// src/infrastructure/event-queue.ts
+var DEFAULT_QUEUE_CONFIG = {
+  batchSize: DEFAULT_CONFIG.batchSize,
+  batchTimeout: DEFAULT_CONFIG.batchTimeout,
+  maxRetries: 3,
+  retryDelayMs: 1e3,
+  storageKey: "_loamly_queue"
+};
+var EventQueue = class {
+  constructor(endpoint2, config2 = {}) {
+    this.queue = [];
+    this.batchTimer = null;
+    this.isFlushing = false;
+    this.endpoint = endpoint2;
+    this.config = { ...DEFAULT_QUEUE_CONFIG, ...config2 };
+    this.loadFromStorage();
+  }
+  /**
+   * Add event to queue
+   */
+  push(type, payload) {
+    const event = {
+      id: this.generateId(),
+      type,
+      payload,
+      timestamp: Date.now(),
+      retries: 0
+    };
+    this.queue.push(event);
+    this.saveToStorage();
+    this.scheduleBatch();
+  }
+  /**
+   * Force flush all events immediately
+   */
+  async flush() {
+    if (this.isFlushing || this.queue.length === 0) return;
+    this.isFlushing = true;
+    this.clearBatchTimer();
+    try {
+      const events = [...this.queue];
+      this.queue = [];
+      await this.sendBatch(events);
+    } finally {
+      this.isFlushing = false;
+      this.saveToStorage();
+    }
+  }
+  /**
+   * Flush using sendBeacon (for unload events)
+   */
+  flushBeacon() {
+    if (this.queue.length === 0) return true;
+    const events = this.queue.map((e) => ({
+      type: e.type,
+      ...e.payload,
+      _queue_id: e.id,
+      _queue_timestamp: e.timestamp
+    }));
+    const success = navigator.sendBeacon?.(
+      this.endpoint,
+      JSON.stringify({ events, beacon: true })
+    ) ?? false;
+    if (success) {
+      this.queue = [];
+      this.clearStorage();
+    }
+    return success;
+  }
+  /**
+   * Get current queue length
+   */
+  get length() {
+    return this.queue.length;
+  }
+  scheduleBatch() {
+    if (this.batchTimer) return;
+    if (this.queue.length >= this.config.batchSize) {
+      this.flush();
+      return;
+    }
+    this.batchTimer = setTimeout(() => {
+      this.batchTimer = null;
+      this.flush();
+    }, this.config.batchTimeout);
+  }
+  clearBatchTimer() {
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+      this.batchTimer = null;
+    }
+  }
+  async sendBatch(events) {
+    if (events.length === 0) return;
+    const payload = {
+      events: events.map((e) => ({
+        type: e.type,
+        ...e.payload,
+        _queue_id: e.id,
+        _queue_timestamp: e.timestamp
+      })),
+      batch: true
+    };
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+    } catch (error) {
+      for (const event of events) {
+        if (event.retries < this.config.maxRetries) {
+          event.retries++;
+          this.queue.push(event);
+        }
+      }
+      if (this.queue.length > 0) {
+        const delay = this.config.retryDelayMs * Math.pow(2, events[0].retries - 1);
+        setTimeout(() => this.flush(), delay);
+      }
+    }
+  }
+  loadFromStorage() {
+    try {
+      const stored = localStorage.getItem(this.config.storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (Array.isArray(parsed)) {
+          const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+          this.queue = parsed.filter((e) => e.timestamp > cutoff);
+        }
+      }
+    } catch {
+    }
+  }
+  saveToStorage() {
+    try {
+      if (this.queue.length > 0) {
+        localStorage.setItem(this.config.storageKey, JSON.stringify(this.queue));
+      } else {
+        this.clearStorage();
+      }
+    } catch {
+    }
+  }
+  clearStorage() {
+    try {
+      localStorage.removeItem(this.config.storageKey);
+    } catch {
+    }
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+};
+
+// src/infrastructure/ping.ts
+var PingService = class {
+  constructor(sessionId2, visitorId2, version, config2 = {}) {
+    this.intervalId = null;
+    this.isVisible = true;
+    this.currentScrollDepth = 0;
+    this.ping = async () => {
+      const data = this.getData();
+      this.config.onPing?.(data);
+      if (this.config.endpoint) {
+        try {
+          await fetch(this.config.endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(data)
+          });
+        } catch {
+        }
+      }
+    };
+    this.handleVisibilityChange = () => {
+      this.isVisible = document.visibilityState === "visible";
+    };
+    this.handleScroll = () => {
+      const scrollPercent = Math.round(
+        (window.scrollY + window.innerHeight) / document.documentElement.scrollHeight * 100
+      );
+      if (scrollPercent > this.currentScrollDepth) {
+        this.currentScrollDepth = Math.min(scrollPercent, 100);
+      }
+    };
+    this.sessionId = sessionId2;
+    this.visitorId = visitorId2;
+    this.version = version;
+    this.pageLoadTime = Date.now();
+    this.config = {
+      interval: DEFAULT_CONFIG.pingInterval,
+      endpoint: "",
+      ...config2
+    };
+    document.addEventListener("visibilitychange", this.handleVisibilityChange);
+    window.addEventListener("scroll", this.handleScroll, { passive: true });
+  }
+  /**
+   * Start the ping service
+   */
+  start() {
+    if (this.intervalId) return;
+    this.intervalId = setInterval(() => {
+      if (this.isVisible) {
+        this.ping();
+      }
+    }, this.config.interval);
+    this.ping();
+  }
+  /**
+   * Stop the ping service
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    document.removeEventListener("visibilitychange", this.handleVisibilityChange);
+    window.removeEventListener("scroll", this.handleScroll);
+  }
+  /**
+   * Update scroll depth (called by external scroll tracker)
+   */
+  updateScrollDepth(depth) {
+    if (depth > this.currentScrollDepth) {
+      this.currentScrollDepth = depth;
+    }
+  }
+  /**
+   * Get current ping data
+   */
+  getData() {
+    return {
+      session_id: this.sessionId,
+      visitor_id: this.visitorId,
+      url: window.location.href,
+      time_on_page_ms: Date.now() - this.pageLoadTime,
+      scroll_depth: this.currentScrollDepth,
+      is_active: this.isVisible,
+      tracker_version: this.version
+    };
+  }
+};
+
+// src/behavioral/scroll-tracker.ts
+var DEFAULT_CHUNKS = [30, 60, 90, 100];
+var ScrollTracker = class {
+  constructor(config2 = {}) {
+    this.maxDepth = 0;
+    this.reportedChunks = /* @__PURE__ */ new Set();
+    this.ticking = false;
+    this.isVisible = true;
+    this.handleScroll = () => {
+      if (!this.ticking && this.isVisible) {
+        requestAnimationFrame(() => {
+          this.checkScrollDepth();
+          this.ticking = false;
+        });
+        this.ticking = true;
+      }
+    };
+    this.handleVisibility = () => {
+      this.isVisible = document.visibilityState === "visible";
+    };
+    this.config = {
+      chunks: DEFAULT_CHUNKS,
+      ...config2
+    };
+    this.startTime = Date.now();
+  }
+  /**
+   * Start tracking scroll depth
+   */
+  start() {
+    window.addEventListener("scroll", this.handleScroll, { passive: true });
+    document.addEventListener("visibilitychange", this.handleVisibility);
+    this.checkScrollDepth();
+  }
+  /**
+   * Stop tracking
+   */
+  stop() {
+    window.removeEventListener("scroll", this.handleScroll);
+    document.removeEventListener("visibilitychange", this.handleVisibility);
+  }
+  /**
+   * Get current max scroll depth
+   */
+  getMaxDepth() {
+    return this.maxDepth;
+  }
+  /**
+   * Get reported chunks
+   */
+  getReportedChunks() {
+    return Array.from(this.reportedChunks).sort((a, b) => a - b);
+  }
+  /**
+   * Get final scroll event (for unload)
+   */
+  getFinalEvent() {
+    const docHeight = document.documentElement.scrollHeight;
+    const viewportHeight = window.innerHeight;
+    return {
+      depth: this.maxDepth,
+      chunk: this.getChunkForDepth(this.maxDepth),
+      time_to_reach_ms: Date.now() - this.startTime,
+      total_height: docHeight,
+      viewport_height: viewportHeight
+    };
+  }
+  checkScrollDepth() {
+    const scrollY = window.scrollY;
+    const viewportHeight = window.innerHeight;
+    const docHeight = document.documentElement.scrollHeight;
+    if (docHeight <= viewportHeight) {
+      this.updateDepth(100);
+      return;
+    }
+    const scrollableHeight = docHeight - viewportHeight;
+    const currentDepth = Math.min(100, Math.round(scrollY / scrollableHeight * 100));
+    this.updateDepth(currentDepth);
+  }
+  updateDepth(depth) {
+    if (depth <= this.maxDepth) return;
+    this.maxDepth = depth;
+    this.config.onDepthChange?.(depth);
+    for (const chunk of this.config.chunks) {
+      if (depth >= chunk && !this.reportedChunks.has(chunk)) {
+        this.reportedChunks.add(chunk);
+        this.reportChunk(chunk);
+      }
+    }
+  }
+  reportChunk(chunk) {
+    const docHeight = document.documentElement.scrollHeight;
+    const viewportHeight = window.innerHeight;
+    const event = {
+      depth: this.maxDepth,
+      chunk,
+      time_to_reach_ms: Date.now() - this.startTime,
+      total_height: docHeight,
+      viewport_height: viewportHeight
+    };
+    this.config.onChunkReached?.(event);
+  }
+  getChunkForDepth(depth) {
+    const chunks = this.config.chunks.sort((a, b) => b - a);
+    for (const chunk of chunks) {
+      if (depth >= chunk) return chunk;
+    }
+    return 0;
+  }
+};
+
+// src/behavioral/time-tracker.ts
+var DEFAULT_CONFIG2 = {
+  idleThresholdMs: 3e4,
+  // 30 seconds
+  updateIntervalMs: 5e3
+  // 5 seconds
+};
+var TimeTracker = class {
+  constructor(config2 = {}) {
+    this.activeTime = 0;
+    this.idleTime = 0;
+    this.isVisible = true;
+    this.isIdle = false;
+    this.updateInterval = null;
+    this.idleCheckInterval = null;
+    this.handleVisibility = () => {
+      const wasVisible = this.isVisible;
+      this.isVisible = document.visibilityState === "visible";
+      if (wasVisible && !this.isVisible) {
+        this.updateTimes();
+      } else if (!wasVisible && this.isVisible) {
+        this.lastUpdateTime = Date.now();
+        this.lastActivityTime = Date.now();
+      }
+    };
+    this.handleActivity = () => {
+      const now = Date.now();
+      if (this.isIdle) {
+        this.isIdle = false;
+      }
+      this.lastActivityTime = now;
+    };
+    this.config = { ...DEFAULT_CONFIG2, ...config2 };
+    this.startTime = Date.now();
+    this.lastActivityTime = this.startTime;
+    this.lastUpdateTime = this.startTime;
+  }
+  /**
+   * Start tracking time
+   */
+  start() {
+    document.addEventListener("visibilitychange", this.handleVisibility);
+    const activityEvents = ["mousemove", "keydown", "scroll", "click", "touchstart"];
+    activityEvents.forEach((event) => {
+      document.addEventListener(event, this.handleActivity, { passive: true });
+    });
+    this.updateInterval = setInterval(() => {
+      this.update();
+    }, this.config.updateIntervalMs);
+    this.idleCheckInterval = setInterval(() => {
+      this.checkIdle();
+    }, 1e3);
+  }
+  /**
+   * Stop tracking
+   */
+  stop() {
+    document.removeEventListener("visibilitychange", this.handleVisibility);
+    const activityEvents = ["mousemove", "keydown", "scroll", "click", "touchstart"];
+    activityEvents.forEach((event) => {
+      document.removeEventListener(event, this.handleActivity);
+    });
+    if (this.updateInterval) {
+      clearInterval(this.updateInterval);
+      this.updateInterval = null;
+    }
+    if (this.idleCheckInterval) {
+      clearInterval(this.idleCheckInterval);
+      this.idleCheckInterval = null;
+    }
+  }
+  /**
+   * Get current time metrics
+   */
+  getMetrics() {
+    this.updateTimes();
+    return {
+      active_time_ms: this.activeTime,
+      total_time_ms: Date.now() - this.startTime,
+      idle_time_ms: this.idleTime,
+      is_engaged: !this.isIdle && this.isVisible
+    };
+  }
+  /**
+   * Get final metrics (for unload)
+   */
+  getFinalMetrics() {
+    this.updateTimes();
+    return this.getMetrics();
+  }
+  checkIdle() {
+    const now = Date.now();
+    const timeSinceActivity = now - this.lastActivityTime;
+    if (!this.isIdle && timeSinceActivity >= this.config.idleThresholdMs) {
+      this.isIdle = true;
+    }
+  }
+  updateTimes() {
+    const now = Date.now();
+    const elapsed = now - this.lastUpdateTime;
+    if (this.isVisible) {
+      if (this.isIdle) {
+        this.idleTime += elapsed;
+      } else {
+        this.activeTime += elapsed;
+      }
+    }
+    this.lastUpdateTime = now;
+  }
+  update() {
+    if (!this.isVisible) return;
+    this.updateTimes();
+    this.config.onUpdate?.(this.getMetrics());
+  }
+};
+
+// src/behavioral/form-tracker.ts
+var DEFAULT_CONFIG3 = {
+  sensitiveFields: [
+    "password",
+    "pwd",
+    "pass",
+    "credit",
+    "card",
+    "cvv",
+    "cvc",
+    "ssn",
+    "social",
+    "secret",
+    "token",
+    "key"
+  ],
+  trackableFields: [
+    "email",
+    "name",
+    "phone",
+    "company",
+    "first",
+    "last",
+    "city",
+    "country"
+  ],
+  thankYouPatterns: [
+    /thank[-_]?you/i,
+    /success/i,
+    /confirmation/i,
+    /submitted/i,
+    /complete/i
+  ]
+};
+var FormTracker = class {
+  constructor(config2 = {}) {
+    this.formStartTimes = /* @__PURE__ */ new Map();
+    this.interactedForms = /* @__PURE__ */ new Set();
+    this.mutationObserver = null;
+    this.handleFocusIn = (e) => {
+      const target = e.target;
+      if (!this.isFormField(target)) return;
+      const form = target.closest("form");
+      const formId = this.getFormId(form || target);
+      if (!this.formStartTimes.has(formId)) {
+        this.formStartTimes.set(formId, Date.now());
+        this.interactedForms.add(formId);
+        this.emitEvent({
+          event_type: "form_start",
+          form_id: formId,
+          form_type: this.detectFormType(form || target)
+        });
+      }
+      const fieldName = this.getFieldName(target);
+      if (fieldName && !this.isSensitiveField(fieldName)) {
+        this.emitEvent({
+          event_type: "form_field",
+          form_id: formId,
+          form_type: this.detectFormType(form || target),
+          field_name: this.sanitizeFieldName(fieldName),
+          field_type: target.type || target.tagName.toLowerCase()
+        });
+      }
+    };
+    this.handleSubmit = (e) => {
+      const form = e.target;
+      if (!form || form.tagName !== "FORM") return;
+      const formId = this.getFormId(form);
+      const startTime = this.formStartTimes.get(formId);
+      this.emitEvent({
+        event_type: "form_submit",
+        form_id: formId,
+        form_type: this.detectFormType(form),
+        time_to_submit_ms: startTime ? Date.now() - startTime : void 0,
+        is_conversion: true
+      });
+    };
+    this.handleClick = (e) => {
+      const target = e.target;
+      if (target.closest(".hs-button") || target.closest('[type="submit"]')) {
+        const form = target.closest("form");
+        if (form && form.classList.contains("hs-form")) {
+          const formId = this.getFormId(form);
+          const startTime = this.formStartTimes.get(formId);
+          this.emitEvent({
+            event_type: "form_submit",
+            form_id: formId,
+            form_type: "hubspot",
+            time_to_submit_ms: startTime ? Date.now() - startTime : void 0,
+            is_conversion: true
+          });
+        }
+      }
+      if (target.closest('[data-qa="submit-button"]')) {
+        this.emitEvent({
+          event_type: "form_submit",
+          form_id: "typeform_embed",
+          form_type: "typeform",
+          is_conversion: true
+        });
+      }
+    };
+    this.config = {
+      ...DEFAULT_CONFIG3,
+      ...config2,
+      sensitiveFields: [
+        ...DEFAULT_CONFIG3.sensitiveFields,
+        ...config2.sensitiveFields || []
+      ]
+    };
+  }
+  /**
+   * Start tracking forms
+   */
+  start() {
+    document.addEventListener("focusin", this.handleFocusIn, { passive: true });
+    document.addEventListener("submit", this.handleSubmit);
+    document.addEventListener("click", this.handleClick, { passive: true });
+    this.startMutationObserver();
+    this.checkThankYouPage();
+    this.scanForEmbeddedForms();
+  }
+  /**
+   * Stop tracking
+   */
+  stop() {
+    document.removeEventListener("focusin", this.handleFocusIn);
+    document.removeEventListener("submit", this.handleSubmit);
+    document.removeEventListener("click", this.handleClick);
+    this.mutationObserver?.disconnect();
+  }
+  /**
+   * Get forms that had interaction
+   */
+  getInteractedForms() {
+    return Array.from(this.interactedForms);
+  }
+  startMutationObserver() {
+    this.mutationObserver = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        for (const node of mutation.addedNodes) {
+          if (node instanceof HTMLElement) {
+            if (node.classList?.contains("hs-form") || node.querySelector?.(".hs-form")) {
+              this.trackEmbeddedForm(node, "hubspot");
+            }
+            if (node.classList?.contains("typeform-widget") || node.querySelector?.("[data-tf-widget]")) {
+              this.trackEmbeddedForm(node, "typeform");
+            }
+            if (node.classList?.contains("jotform-form") || node.querySelector?.(".jotform-form")) {
+              this.trackEmbeddedForm(node, "jotform");
+            }
+            if (node.classList?.contains("gform_wrapper") || node.querySelector?.(".gform_wrapper")) {
+              this.trackEmbeddedForm(node, "gravity");
+            }
+          }
+        }
+      }
+    });
+    this.mutationObserver.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+  }
+  scanForEmbeddedForms() {
+    document.querySelectorAll(".hs-form").forEach((form) => {
+      this.trackEmbeddedForm(form, "hubspot");
+    });
+    document.querySelectorAll("[data-tf-widget], .typeform-widget").forEach((form) => {
+      this.trackEmbeddedForm(form, "typeform");
+    });
+    document.querySelectorAll(".jotform-form").forEach((form) => {
+      this.trackEmbeddedForm(form, "jotform");
+    });
+    document.querySelectorAll(".gform_wrapper").forEach((form) => {
+      this.trackEmbeddedForm(form, "gravity");
+    });
+  }
+  trackEmbeddedForm(element, type) {
+    const formId = `${type}_${this.getFormId(element)}`;
+    element.addEventListener("focusin", () => {
+      if (!this.formStartTimes.has(formId)) {
+        this.formStartTimes.set(formId, Date.now());
+        this.interactedForms.add(formId);
+        this.emitEvent({
+          event_type: "form_start",
+          form_id: formId,
+          form_type: type
+        });
+      }
+    }, { passive: true });
+  }
+  checkThankYouPage() {
+    const url = window.location.href.toLowerCase();
+    const title = document.title.toLowerCase();
+    for (const pattern of this.config.thankYouPatterns) {
+      if (pattern.test(url) || pattern.test(title)) {
+        this.emitEvent({
+          event_type: "form_success",
+          form_id: "page_conversion",
+          form_type: "unknown",
+          is_conversion: true
+        });
+        break;
+      }
+    }
+  }
+  isFormField(element) {
+    const tagName = element.tagName;
+    return tagName === "INPUT" || tagName === "TEXTAREA" || tagName === "SELECT";
+  }
+  getFormId(element) {
+    if (!element) return "unknown";
+    return element.id || element.getAttribute("name") || element.getAttribute("data-form-id") || "form_" + Math.random().toString(36).substring(2, 8);
+  }
+  getFieldName(input) {
+    return input.name || input.id || input.getAttribute("data-name") || "";
+  }
+  isSensitiveField(fieldName) {
+    const lowerName = fieldName.toLowerCase();
+    return this.config.sensitiveFields.some((sensitive) => lowerName.includes(sensitive));
+  }
+  sanitizeFieldName(fieldName) {
+    return fieldName.replace(/[0-9]+/g, "*").substring(0, 50);
+  }
+  detectFormType(element) {
+    if (element.classList.contains("hs-form") || element.closest(".hs-form")) {
+      return "hubspot";
+    }
+    if (element.classList.contains("typeform-widget") || element.closest("[data-tf-widget]")) {
+      return "typeform";
+    }
+    if (element.classList.contains("jotform-form") || element.closest(".jotform-form")) {
+      return "jotform";
+    }
+    if (element.classList.contains("gform_wrapper") || element.closest(".gform_wrapper")) {
+      return "gravity";
+    }
+    if (element.tagName === "FORM") {
+      return "native";
+    }
+    return "unknown";
+  }
+  emitEvent(event) {
+    this.config.onFormEvent?.(event);
+  }
+};
+
+// src/spa/router.ts
+var SPARouter = class {
+  constructor(config2 = {}) {
+    this.originalPushState = null;
+    this.originalReplaceState = null;
+    this.handleStateChange = (type) => {
+      const newUrl = window.location.href;
+      if (newUrl !== this.currentUrl) {
+        this.emitNavigation(newUrl, type);
+      }
+    };
+    this.handlePopState = () => {
+      const newUrl = window.location.href;
+      if (newUrl !== this.currentUrl) {
+        this.emitNavigation(newUrl, "pop");
+      }
+    };
+    this.handleHashChange = () => {
+      const newUrl = window.location.href;
+      if (newUrl !== this.currentUrl) {
+        this.emitNavigation(newUrl, "hash");
+      }
+    };
+    this.config = config2;
+    this.currentUrl = window.location.href;
+    this.pageEnterTime = Date.now();
+  }
+  /**
+   * Start listening for navigation events
+   */
+  start() {
+    this.patchHistoryAPI();
+    window.addEventListener("popstate", this.handlePopState);
+    if (!this.config.ignoreHashChange) {
+      window.addEventListener("hashchange", this.handleHashChange);
+    }
+  }
+  /**
+   * Stop listening and restore original methods
+   */
+  stop() {
+    if (this.originalPushState) {
+      history.pushState = this.originalPushState;
+    }
+    if (this.originalReplaceState) {
+      history.replaceState = this.originalReplaceState;
+    }
+    window.removeEventListener("popstate", this.handlePopState);
+    window.removeEventListener("hashchange", this.handleHashChange);
+  }
+  /**
+   * Manually trigger a navigation event (for custom routers)
+   */
+  navigate(url, type = "push") {
+    this.emitNavigation(url, type);
+  }
+  /**
+   * Get current URL
+   */
+  getCurrentUrl() {
+    return this.currentUrl;
+  }
+  /**
+   * Get time on current page
+   */
+  getTimeOnPage() {
+    return Date.now() - this.pageEnterTime;
+  }
+  patchHistoryAPI() {
+    this.originalPushState = history.pushState.bind(history);
+    this.originalReplaceState = history.replaceState.bind(history);
+    history.pushState = (...args) => {
+      const result = this.originalPushState(...args);
+      this.handleStateChange("push");
+      return result;
+    };
+    history.replaceState = (...args) => {
+      const result = this.originalReplaceState(...args);
+      this.handleStateChange("replace");
+      return result;
+    };
+  }
+  emitNavigation(toUrl, type) {
+    const event = {
+      from_url: this.currentUrl,
+      to_url: toUrl,
+      navigation_type: type,
+      time_on_previous_page_ms: Date.now() - this.pageEnterTime
+    };
+    this.currentUrl = toUrl;
+    this.pageEnterTime = Date.now();
+    this.config.onNavigate?.(event);
+  }
+};
+
 // src/utils.ts
 function generateUUID() {
   if (typeof crypto !== "undefined" && crypto.randomUUID) {
@@ -754,13 +1773,19 @@ var initialized = false;
 var debugMode = false;
 var visitorId = null;
 var sessionId = null;
-var sessionStartTime = null;
 var navigationTiming = null;
 var aiDetection = null;
 var behavioralClassifier = null;
 var behavioralMLResult = null;
 var focusBlurAnalyzer = null;
 var focusBlurResult = null;
+var agenticAnalyzer = null;
+var eventQueue = null;
+var pingService = null;
+var scrollTracker = null;
+var timeTracker = null;
+var formTracker = null;
+var spaRouter = null;
 function log(...args) {
   if (debugMode) {
     console.log("[Loamly]", ...args);
@@ -785,8 +1810,11 @@ function init(userConfig = {}) {
   log("Visitor ID:", visitorId);
   const session = getSessionId();
   sessionId = session.sessionId;
-  sessionStartTime = Date.now();
   log("Session ID:", sessionId, session.isNew ? "(new)" : "(existing)");
+  eventQueue = new EventQueue(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
+    batchSize: DEFAULT_CONFIG.batchSize,
+    batchTimeout: DEFAULT_CONFIG.batchTimeout
+  });
   navigationTiming = detectNavigationType();
   log("Navigation timing:", navigationTiming);
   aiDetection = detectAIFromReferrer(document.referrer) || detectAIFromUTM(window.location.href);
@@ -798,7 +1826,7 @@ function init(userConfig = {}) {
     pageview();
   }
   if (!userConfig.disableBehavioral) {
-    setupBehavioralTracking();
+    setupAdvancedBehavioralTracking();
   }
   behavioralClassifier = new BehavioralClassifier(1e4);
   behavioralClassifier.setOnClassify(handleBehavioralClassification);
@@ -810,182 +1838,234 @@ function init(userConfig = {}) {
       handleFocusBlurAnalysis(focusBlurAnalyzer.analyze());
     }
   }, 5e3);
+  agenticAnalyzer = new AgenticBrowserAnalyzer();
+  agenticAnalyzer.init();
+  if (visitorId && sessionId) {
+    pingService = new PingService(sessionId, visitorId, VERSION, {
+      interval: DEFAULT_CONFIG.pingInterval,
+      endpoint: endpoint(DEFAULT_CONFIG.endpoints.ping)
+    });
+    pingService.start();
+  }
+  spaRouter = new SPARouter({
+    onNavigate: handleSPANavigation
+  });
+  spaRouter.start();
+  setupUnloadHandlers();
   log("Initialization complete");
 }
-function pageview(customUrl) {
-  if (!initialized) {
-    log("Not initialized, call init() first");
-    return;
-  }
-  const url = customUrl || window.location.href;
-  const payload = {
-    visitor_id: visitorId,
-    session_id: sessionId,
-    url,
-    referrer: document.referrer || null,
-    title: document.title || null,
-    utm_source: extractUTMParams(url).utm_source || null,
-    utm_medium: extractUTMParams(url).utm_medium || null,
-    utm_campaign: extractUTMParams(url).utm_campaign || null,
-    user_agent: navigator.userAgent,
-    screen_width: window.screen?.width,
-    screen_height: window.screen?.height,
-    language: navigator.language,
-    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    tracker_version: VERSION,
-    navigation_timing: navigationTiming,
-    ai_platform: aiDetection?.platform || null,
-    is_ai_referrer: aiDetection?.isAI || false
-  };
-  log("Pageview:", payload);
-  safeFetch(endpoint(DEFAULT_CONFIG.endpoints.visit), {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(payload)
+function setupAdvancedBehavioralTracking() {
+  scrollTracker = new ScrollTracker({
+    chunks: [30, 60, 90, 100],
+    onChunkReached: (event) => {
+      log("Scroll chunk:", event.chunk);
+      queueEvent("scroll_depth", {
+        depth: event.depth,
+        chunk: event.chunk,
+        time_to_reach_ms: event.time_to_reach_ms
+      });
+    }
+  });
+  scrollTracker.start();
+  timeTracker = new TimeTracker({
+    updateIntervalMs: 1e4,
+    // Report every 10 seconds
+    onUpdate: (event) => {
+      if (event.active_time_ms >= DEFAULT_CONFIG.timeSpentThresholdMs) {
+        queueEvent("time_spent", {
+          active_time_ms: event.active_time_ms,
+          total_time_ms: event.total_time_ms,
+          idle_time_ms: event.idle_time_ms,
+          is_engaged: event.is_engaged
+        });
+      }
+    }
+  });
+  timeTracker.start();
+  formTracker = new FormTracker({
+    onFormEvent: (event) => {
+      log("Form event:", event.event_type, event.form_id);
+      queueEvent(event.event_type, {
+        form_id: event.form_id,
+        form_type: event.form_type,
+        field_name: event.field_name,
+        field_type: event.field_type,
+        time_to_submit_ms: event.time_to_submit_ms,
+        is_conversion: event.is_conversion
+      });
+    }
+  });
+  formTracker.start();
+  document.addEventListener("click", (e) => {
+    const target = e.target;
+    const link = target.closest("a");
+    if (link && link.href) {
+      const isExternal = link.hostname !== window.location.hostname;
+      queueEvent("click", {
+        element: "link",
+        href: truncateText(link.href, 200),
+        text: truncateText(link.textContent || "", 100),
+        is_external: isExternal
+      });
+    }
   });
 }
-function track(eventName, options = {}) {
-  if (!initialized) {
-    log("Not initialized, call init() first");
-    return;
-  }
-  const payload = {
+function queueEvent(eventType, data) {
+  if (!eventQueue) return;
+  eventQueue.push(eventType, {
     visitor_id: visitorId,
     session_id: sessionId,
-    event_name: eventName,
-    event_type: "custom",
-    properties: options.properties || {},
-    revenue: options.revenue,
-    currency: options.currency || "USD",
+    event_type: eventType,
+    ...data,
     url: window.location.href,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     tracker_version: VERSION
-  };
-  log("Event:", eventName, payload);
-  safeFetch(endpoint("/api/ingest/event"), {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(payload)
-  });
-}
-function conversion(eventName, revenue, currency = "USD") {
-  track(eventName, { revenue, currency, properties: { type: "conversion" } });
-}
-function identify(userId, traits = {}) {
-  if (!initialized) {
-    log("Not initialized, call init() first");
-    return;
-  }
-  log("Identify:", userId, traits);
-  const payload = {
-    visitor_id: visitorId,
-    session_id: sessionId,
-    user_id: userId,
-    traits,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  safeFetch(endpoint("/api/ingest/identify"), {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(payload)
   });
 }
-function setupBehavioralTracking() {
-  let maxScrollDepth = 0;
-  let lastScrollUpdate = 0;
-  let lastTimeUpdate = Date.now();
-  let scrollTicking = false;
-  window.addEventListener("scroll", () => {
-    if (!scrollTicking) {
-      requestAnimationFrame(() => {
-        const scrollPercent = Math.round(
-          (window.scrollY + window.innerHeight) / document.documentElement.scrollHeight * 100
-        );
-        if (scrollPercent > maxScrollDepth) {
-          maxScrollDepth = scrollPercent;
-          const milestones = [25, 50, 75, 100];
-          for (const milestone of milestones) {
-            if (scrollPercent >= milestone && lastScrollUpdate < milestone) {
-              lastScrollUpdate = milestone;
-              sendBehavioralEvent("scroll_depth", { depth: milestone });
-            }
-          }
-        }
-        scrollTicking = false;
+function handleSPANavigation(event) {
+  log("SPA navigation:", event.navigation_type, event.to_url);
+  eventQueue?.flush();
+  pingService?.updateScrollDepth(0);
+  scrollTracker?.stop();
+  scrollTracker = new ScrollTracker({
+    chunks: [30, 60, 90, 100],
+    onChunkReached: (scrollEvent) => {
+      queueEvent("scroll_depth", {
+        depth: scrollEvent.depth,
+        chunk: scrollEvent.chunk,
+        time_to_reach_ms: scrollEvent.time_to_reach_ms
       });
-      scrollTicking = true;
     }
   });
-  const trackTimeSpent = () => {
-    const now = Date.now();
-    const delta = now - lastTimeUpdate;
-    if (delta >= DEFAULT_CONFIG.timeSpentThresholdMs) {
-      lastTimeUpdate = now;
-      sendBehavioralEvent("time_spent", {
-        seconds: Math.round(delta / 1e3),
-        total_seconds: Math.round((now - (sessionStartTime || now)) / 1e3)
-      });
-    }
-  };
-  document.addEventListener("visibilitychange", () => {
-    if (document.visibilityState === "hidden") {
-      trackTimeSpent();
-    }
+  scrollTracker.start();
+  pageview(event.to_url);
+  queueEvent("spa_navigation", {
+    from_url: event.from_url,
+    to_url: event.to_url,
+    navigation_type: event.navigation_type,
+    time_on_previous_page_ms: event.time_on_previous_page_ms
   });
-  window.addEventListener("beforeunload", () => {
-    trackTimeSpent();
-    if (maxScrollDepth > 0) {
+}
+function setupUnloadHandlers() {
+  const handleUnload = () => {
+    const scrollEvent = scrollTracker?.getFinalEvent();
+    if (scrollEvent) {
       sendBeacon(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
         visitor_id: visitorId,
         session_id: sessionId,
         event_type: "scroll_depth_final",
-        data: { depth: maxScrollDepth },
+        data: scrollEvent,
         url: window.location.href
       });
     }
-  });
-  document.addEventListener("focusin", (e) => {
-    const target = e.target;
-    if (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.tagName === "SELECT") {
-      sendBehavioralEvent("form_focus", {
-        field_type: target.tagName.toLowerCase(),
-        field_name: target.name || target.id || "unknown"
+    const timeEvent = timeTracker?.getFinalMetrics();
+    if (timeEvent) {
+      sendBeacon(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
+        visitor_id: visitorId,
+        session_id: sessionId,
+        event_type: "time_spent_final",
+        data: timeEvent,
+        url: window.location.href
       });
     }
-  });
-  document.addEventListener("submit", (e) => {
-    const form = e.target;
-    sendBehavioralEvent("form_submit", {
-      form_id: form.id || form.name || "unknown",
-      form_action: form.action ? new URL(form.action).pathname : "unknown"
-    });
-  });
-  document.addEventListener("click", (e) => {
-    const target = e.target;
-    const link = target.closest("a");
-    if (link && link.href) {
-      const isExternal = link.hostname !== window.location.hostname;
-      sendBehavioralEvent("click", {
-        element: "link",
-        href: truncateText(link.href, 200),
-        text: truncateText(link.textContent || "", 100),
-        is_external: isExternal
+    const agenticResult = agenticAnalyzer?.getResult();
+    if (agenticResult && agenticResult.agenticProbability > 0) {
+      sendBeacon(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
+        visitor_id: visitorId,
+        session_id: sessionId,
+        event_type: "agentic_detection",
+        data: agenticResult,
+        url: window.location.href
       });
     }
+    eventQueue?.flushBeacon();
+    if (behavioralClassifier && !behavioralClassifier.hasClassified()) {
+      const result = behavioralClassifier.forceClassify();
+      if (result) {
+        handleBehavioralClassification(result);
+      }
+    }
+  };
+  window.addEventListener("beforeunload", handleUnload);
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "hidden") {
+      handleUnload();
+    }
+  });
+}
+function pageview(customUrl) {
+  if (!initialized) {
+    log("Not initialized, call init() first");
+    return;
+  }
+  const url = customUrl || window.location.href;
+  const payload = {
+    visitor_id: visitorId,
+    session_id: sessionId,
+    url,
+    referrer: document.referrer || null,
+    title: document.title || null,
+    utm_source: extractUTMParams(url).utm_source || null,
+    utm_medium: extractUTMParams(url).utm_medium || null,
+    utm_campaign: extractUTMParams(url).utm_campaign || null,
+    user_agent: navigator.userAgent,
+    screen_width: window.screen?.width,
+    screen_height: window.screen?.height,
+    language: navigator.language,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    tracker_version: VERSION,
+    navigation_timing: navigationTiming,
+    ai_platform: aiDetection?.platform || null,
+    is_ai_referrer: aiDetection?.isAI || false
+  };
+  log("Pageview:", payload);
+  safeFetch(endpoint(DEFAULT_CONFIG.endpoints.visit), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
   });
 }
-function sendBehavioralEvent(eventType, data) {
+function track(eventName, options = {}) {
+  if (!initialized) {
+    log("Not initialized, call init() first");
+    return;
+  }
   const payload = {
     visitor_id: visitorId,
     session_id: sessionId,
-    event_type: eventType,
-    data,
+    event_name: eventName,
+    event_type: "custom",
+    properties: options.properties || {},
+    revenue: options.revenue,
+    currency: options.currency || "USD",
     url: window.location.href,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     tracker_version: VERSION
   };
-  log("Behavioral:", eventType, data);
-  safeFetch(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
+  log("Event:", eventName, payload);
+  safeFetch(endpoint("/api/ingest/event"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+}
+function conversion(eventName, revenue, currency = "USD") {
+  track(eventName, { revenue, currency, properties: { type: "conversion" } });
+}
+function identify(userId, traits = {}) {
+  if (!initialized) {
+    log("Not initialized, call init() first");
+    return;
+  }
+  log("Identify:", userId, traits);
+  const payload = {
+    visitor_id: visitorId,
+    session_id: sessionId,
+    user_id: userId,
+    traits,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  safeFetch(endpoint("/api/ingest/identify"), {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(payload)
@@ -1031,14 +2111,6 @@ function setupBehavioralMLTracking() {
       }
     }
   }, { passive: true });
-  window.addEventListener("beforeunload", () => {
-    if (behavioralClassifier && !behavioralClassifier.hasClassified()) {
-      const result = behavioralClassifier.forceClassify();
-      if (result) {
-        handleBehavioralClassification(result);
-      }
-    }
-  });
   setTimeout(() => {
     if (behavioralClassifier && !behavioralClassifier.hasClassified()) {
       behavioralClassifier.forceClassify();
@@ -1055,7 +2127,7 @@ function handleBehavioralClassification(result) {
     signals: result.signals,
     sessionDurationMs: result.sessionDurationMs
   };
-  sendBehavioralEvent("ml_classification", {
+  queueEvent("ml_classification", {
     classification: result.classification,
     human_probability: result.humanProbability,
     ai_probability: result.aiProbability,
@@ -1083,7 +2155,7 @@ function handleFocusBlurAnalysis(result) {
     signals: result.signals,
     timeToFirstInteractionMs: result.time_to_first_interaction_ms
   };
-  sendBehavioralEvent("focus_blur_analysis", {
+  queueEvent("focus_blur_analysis", {
     nav_type: result.nav_type,
     confidence: result.confidence,
     signals: result.signals,
@@ -1119,21 +2191,36 @@ function getBehavioralMLResult() {
 function getFocusBlurResult() {
   return focusBlurResult;
 }
+function getAgenticResult() {
+  return agenticAnalyzer?.getResult() || null;
+}
 function isTrackerInitialized() {
   return initialized;
 }
 function reset() {
   log("Resetting tracker");
+  pingService?.stop();
+  scrollTracker?.stop();
+  timeTracker?.stop();
+  formTracker?.stop();
+  spaRouter?.stop();
+  agenticAnalyzer?.destroy();
   initialized = false;
   visitorId = null;
   sessionId = null;
-  sessionStartTime = null;
   navigationTiming = null;
   aiDetection = null;
   behavioralClassifier = null;
   behavioralMLResult = null;
   focusBlurAnalyzer = null;
   focusBlurResult = null;
+  agenticAnalyzer = null;
+  eventQueue = null;
+  pingService = null;
+  scrollTracker = null;
+  timeTracker = null;
+  formTracker = null;
+  spaRouter = null;
   try {
     sessionStorage.removeItem("loamly_session");
     sessionStorage.removeItem("loamly_start");
@@ -1156,211 +2243,11 @@ var loamly = {
   getNavigationTiming: getNavigationTimingResult,
   getBehavioralML: getBehavioralMLResult,
   getFocusBlur: getFocusBlurResult,
+  getAgentic: getAgenticResult,
   isInitialized: isTrackerInitialized,
   reset,
   debug: setDebug
 };
-
-// src/detection/agentic-browser.ts
-var CometDetector = class {
-  constructor() {
-    this.detected = false;
-    this.checkComplete = false;
-    this.observer = null;
-  }
-  /**
-   * Initialize detection
-   * @param timeout - Max time to observe for Comet DOM (default: 5s)
-   */
-  init(timeout = 5e3) {
-    if (typeof document === "undefined") return;
-    this.check();
-    if (!this.detected && document.body) {
-      this.observer = new MutationObserver(() => this.check());
-      this.observer.observe(document.body, { childList: true, subtree: true });
-      setTimeout(() => {
-        if (this.observer && !this.detected) {
-          this.observer.disconnect();
-          this.observer = null;
-          this.checkComplete = true;
-        }
-      }, timeout);
-    }
-  }
-  check() {
-    if (document.querySelector(".pplx-agent-overlay-stop-button")) {
-      this.detected = true;
-      this.checkComplete = true;
-      if (this.observer) {
-        this.observer.disconnect();
-        this.observer = null;
-      }
-    }
-  }
-  isDetected() {
-    return this.detected;
-  }
-  isCheckComplete() {
-    return this.checkComplete;
-  }
-  destroy() {
-    if (this.observer) {
-      this.observer.disconnect();
-      this.observer = null;
-    }
-  }
-};
-var MouseAnalyzer = class {
-  /**
-   * @param teleportThreshold - Distance in pixels to consider a teleport (default: 500)
-   */
-  constructor(teleportThreshold = 500) {
-    this.lastX = -1;
-    this.lastY = -1;
-    this.teleportingClicks = 0;
-    this.totalMovements = 0;
-    this.handleMove = (e) => {
-      this.totalMovements++;
-      this.lastX = e.clientX;
-      this.lastY = e.clientY;
-    };
-    this.handleClick = (e) => {
-      if (this.lastX !== -1 && this.lastY !== -1) {
-        const dx = Math.abs(e.clientX - this.lastX);
-        const dy = Math.abs(e.clientY - this.lastY);
-        if (dx > this.teleportThreshold || dy > this.teleportThreshold) {
-          this.teleportingClicks++;
-        }
-      }
-      this.lastX = e.clientX;
-      this.lastY = e.clientY;
-    };
-    this.teleportThreshold = teleportThreshold;
-  }
-  /**
-   * Initialize mouse tracking
-   */
-  init() {
-    if (typeof document === "undefined") return;
-    document.addEventListener("mousemove", this.handleMove, { passive: true });
-    document.addEventListener("mousedown", this.handleClick, { passive: true });
-  }
-  getPatterns() {
-    return {
-      teleportingClicks: this.teleportingClicks,
-      totalMovements: this.totalMovements
-    };
-  }
-  destroy() {
-    if (typeof document === "undefined") return;
-    document.removeEventListener("mousemove", this.handleMove);
-    document.removeEventListener("mousedown", this.handleClick);
-  }
-};
-var CDPDetector = class {
-  constructor() {
-    this.detected = false;
-  }
-  /**
-   * Run detection checks
-   */
-  detect() {
-    if (typeof navigator === "undefined") return false;
-    if (navigator.webdriver) {
-      this.detected = true;
-      return true;
-    }
-    if (typeof window !== "undefined") {
-      const win = window;
-      const automationProps = [
-        "__webdriver_evaluate",
-        "__selenium_evaluate",
-        "__webdriver_script_function",
-        "__webdriver_script_func",
-        "__webdriver_script_fn",
-        "__fxdriver_evaluate",
-        "__driver_unwrapped",
-        "__webdriver_unwrapped",
-        "__driver_evaluate",
-        "__selenium_unwrapped",
-        "__fxdriver_unwrapped"
-      ];
-      for (const prop of automationProps) {
-        if (prop in win) {
-          this.detected = true;
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  isDetected() {
-    return this.detected;
-  }
-};
-var AgenticBrowserAnalyzer = class {
-  constructor() {
-    this.initialized = false;
-    this.cometDetector = new CometDetector();
-    this.mouseAnalyzer = new MouseAnalyzer();
-    this.cdpDetector = new CDPDetector();
-  }
-  /**
-   * Initialize all detectors
-   */
-  init() {
-    if (this.initialized) return;
-    this.initialized = true;
-    this.cometDetector.init();
-    this.mouseAnalyzer.init();
-    this.cdpDetector.detect();
-  }
-  /**
-   * Get current detection result
-   */
-  getResult() {
-    const signals = [];
-    let probability = 0;
-    if (this.cometDetector.isDetected()) {
-      signals.push("comet_dom_detected");
-      probability = Math.max(probability, 0.85);
-    }
-    if (this.cdpDetector.isDetected()) {
-      signals.push("cdp_detected");
-      probability = Math.max(probability, 0.92);
-    }
-    const mousePatterns = this.mouseAnalyzer.getPatterns();
-    if (mousePatterns.teleportingClicks > 0) {
-      signals.push(`teleporting_clicks:${mousePatterns.teleportingClicks}`);
-      probability = Math.max(probability, 0.78);
-    }
-    return {
-      cometDOMDetected: this.cometDetector.isDetected(),
-      cdpDetected: this.cdpDetector.isDetected(),
-      mousePatterns,
-      agenticProbability: probability,
-      signals
-    };
-  }
-  /**
-   * Cleanup resources
-   */
-  destroy() {
-    this.cometDetector.destroy();
-    this.mouseAnalyzer.destroy();
-  }
-};
-function createAgenticAnalyzer() {
-  const analyzer = new AgenticBrowserAnalyzer();
-  if (typeof document !== "undefined") {
-    if (document.readyState === "loading") {
-      document.addEventListener("DOMContentLoaded", () => analyzer.init());
-    } else {
-      analyzer.init();
-    }
-  }
-  return analyzer;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AI_BOT_PATTERNS,