@loamly/tracker 1.8.0 → 2.0.0

package/dist/loamly.iife.global.js

@@ -26,7 +26,7 @@ var Loamly = (() => {
   });
 
   // src/config.ts
-  var VERSION = "1.8.0";
+  var VERSION = "2.0.0";
   var DEFAULT_CONFIG = {
     apiHost: "https://app.loamly.ai",
     endpoints: {
@@ -652,6 +652,1014 @@ var Loamly = (() => {
     }
   };
 
+  // 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();
+    }
+  };
+
+  // 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) {
@@ -734,13 +1742,19 @@ var Loamly = (() => {
   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);
@@ -765,8 +1779,11 @@ var Loamly = (() => {
     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);
@@ -778,7 +1795,7 @@ var Loamly = (() => {
       pageview();
     }
     if (!userConfig.disableBehavioral) {
-      setupBehavioralTracking();
+      setupAdvancedBehavioralTracking();
     }
     behavioralClassifier = new BehavioralClassifier(1e4);
     behavioralClassifier.setOnClassify(handleBehavioralClassification);
@@ -790,8 +1807,161 @@ var Loamly = (() => {
         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 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 queueEvent(eventType, data) {
+    if (!eventQueue) return;
+    eventQueue.push(eventType, {
+      visitor_id: visitorId,
+      session_id: sessionId,
+      event_type: eventType,
+      ...data,
+      url: window.location.href,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      tracker_version: VERSION
+    });
+  }
+  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
+        });
+      }
+    });
+    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
+    });
+  }
+  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: scrollEvent,
+          url: window.location.href
+        });
+      }
+      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
+        });
+      }
+      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");
@@ -870,107 +2040,6 @@ var Loamly = (() => {
       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;
-        });
-        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();
-      }
-    });
-    window.addEventListener("beforeunload", () => {
-      trackTimeSpent();
-      if (maxScrollDepth > 0) {
-        sendBeacon(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
-          visitor_id: visitorId,
-          session_id: sessionId,
-          event_type: "scroll_depth_final",
-          data: { depth: maxScrollDepth },
-          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"
-        });
-      }
-    });
-    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
-        });
-      }
-    });
-  }
-  function sendBehavioralEvent(eventType, data) {
-    const payload = {
-      visitor_id: visitorId,
-      session_id: sessionId,
-      event_type: eventType,
-      data,
-      url: window.location.href,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      tracker_version: VERSION
-    };
-    log("Behavioral:", eventType, data);
-    safeFetch(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload)
-    });
-  }
   function setupBehavioralMLTracking() {
     if (!behavioralClassifier) return;
     let mouseSampleCount = 0;
@@ -1011,14 +2080,6 @@ var Loamly = (() => {
         }
       }
     }, { passive: true });
-    window.addEventListener("beforeunload", () => {
-      if (behavioralClassifier && !behavioralClassifier.hasClassified()) {
-        const result = behavioralClassifier.forceClassify();
-        if (result) {
-          handleBehavioralClassification(result);
-        }
-      }
-    });
     setTimeout(() => {
       if (behavioralClassifier && !behavioralClassifier.hasClassified()) {
         behavioralClassifier.forceClassify();
@@ -1035,7 +2096,7 @@ var Loamly = (() => {
       signals: result.signals,
       sessionDurationMs: result.sessionDurationMs
     };
-    sendBehavioralEvent("ml_classification", {
+    queueEvent("ml_classification", {
       classification: result.classification,
       human_probability: result.humanProbability,
       ai_probability: result.aiProbability,
@@ -1063,7 +2124,7 @@ var Loamly = (() => {
       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,
@@ -1099,21 +2160,36 @@ var Loamly = (() => {
   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");
@@ -1136,50 +2212,110 @@ var Loamly = (() => {
     getNavigationTiming: getNavigationTimingResult,
     getBehavioralML: getBehavioralMLResult,
     getFocusBlur: getFocusBlurResult,
+    getAgentic: getAgenticResult,
     isInitialized: isTrackerInitialized,
     reset,
     debug: setDebug
   };
 
   // src/browser.ts
-  function autoInit() {
+  function extractDomainFromScriptUrl() {
     const scripts = document.getElementsByTagName("script");
-    let scriptTag = null;
     for (const script of scripts) {
-      if (script.src.includes("loamly") || script.dataset.loamly !== void 0) {
-        scriptTag = script;
-        break;
+      const src = script.src;
+      if (src.includes("t.js") || src.includes("loamly")) {
+        try {
+          const url = new URL(src);
+          const domain = url.searchParams.get("d");
+          if (domain) return domain;
+        } catch {
+        }
       }
     }
-    if (!scriptTag) {
-      return;
-    }
-    const config2 = {};
-    if (scriptTag.dataset.apiKey) {
-      config2.apiKey = scriptTag.dataset.apiKey;
-    }
-    if (scriptTag.dataset.apiHost) {
-      config2.apiHost = scriptTag.dataset.apiHost;
+    return null;
+  }
+  async function resolveWorkspaceConfig(domain) {
+    try {
+      const response = await fetch(`${DEFAULT_CONFIG.apiHost}${DEFAULT_CONFIG.endpoints.resolve}?domain=${encodeURIComponent(domain)}`);
+      if (!response.ok) {
+        console.warn("[Loamly] Failed to resolve workspace for domain:", domain);
+        return null;
+      }
+      const data = await response.json();
+      if (data.workspace_id) {
+        return {
+          apiKey: data.workspace_api_key,
+          apiHost: DEFAULT_CONFIG.apiHost
+        };
+      }
+      return null;
+    } catch (error) {
+      console.warn("[Loamly] Error resolving workspace:", error);
+      return null;
     }
-    if (scriptTag.dataset.debug === "true") {
-      config2.debug = true;
+  }
+  function extractConfigFromDataAttributes() {
+    const scripts = document.getElementsByTagName("script");
+    for (const script of scripts) {
+      if (script.src.includes("loamly") || script.dataset.loamly !== void 0) {
+        const config2 = {};
+        if (script.dataset.apiKey) {
+          config2.apiKey = script.dataset.apiKey;
+        }
+        if (script.dataset.apiHost) {
+          config2.apiHost = script.dataset.apiHost;
+        }
+        if (script.dataset.debug === "true") {
+          config2.debug = true;
+        }
+        if (script.dataset.disableAutoPageview === "true") {
+          config2.disableAutoPageview = true;
+        }
+        if (script.dataset.disableBehavioral === "true") {
+          config2.disableBehavioral = true;
+        }
+        if (config2.apiKey) {
+          return config2;
+        }
+      }
     }
-    if (scriptTag.dataset.disableAutoPageview === "true") {
-      config2.disableAutoPageview = true;
+    return null;
+  }
+  async function autoInit() {
+    const domain = extractDomainFromScriptUrl();
+    if (domain) {
+      const resolvedConfig = await resolveWorkspaceConfig(domain);
+      if (resolvedConfig) {
+        loamly.init(resolvedConfig);
+        return;
+      }
     }
-    if (scriptTag.dataset.disableBehavioral === "true") {
-      config2.disableBehavioral = true;
+    const dataConfig = extractConfigFromDataAttributes();
+    if (dataConfig) {
+      loamly.init(dataConfig);
+      return;
     }
-    if (config2.apiKey || scriptTag.dataset.loamly !== void 0) {
-      loamly.init(config2);
+    const currentDomain = window.location.hostname;
+    if (currentDomain && currentDomain !== "localhost") {
+      const resolvedConfig = await resolveWorkspaceConfig(currentDomain);
+      if (resolvedConfig) {
+        loamly.init(resolvedConfig);
+        return;
+      }
     }
   }
   if (typeof document !== "undefined") {
     if (document.readyState === "loading") {
-      document.addEventListener("DOMContentLoaded", autoInit);
+      document.addEventListener("DOMContentLoaded", () => {
+        if (typeof requestIdleCallback !== "undefined") {
+          requestIdleCallback(() => autoInit());
+        } else {
+          setTimeout(autoInit, 0);
+        }
+      });
     } else {
       if (typeof requestIdleCallback !== "undefined") {
-        requestIdleCallback(autoInit);
+        requestIdleCallback(() => autoInit());
       } else {
         setTimeout(autoInit, 0);
       }
@@ -1195,4 +2331,19 @@ var Loamly = (() => {
  * @license MIT
  * @see https://github.com/loamly/loamly
  */
+/**
+ * Agentic Browser Detection
+ * 
+ * LOA-187: Detects AI agentic browsers like Perplexity Comet, ChatGPT Atlas,
+ * and other automated browsing agents.
+ * 
+ * Detection methods:
+ * - DOM fingerprinting (Perplexity Comet overlay)
+ * - Mouse movement patterns (teleporting clicks)
+ * - CDP (Chrome DevTools Protocol) automation fingerprint
+ * - navigator.webdriver detection
+ * 
+ * @module @loamly/tracker/detection/agentic-browser
+ * @license MIT
+ */
 //# sourceMappingURL=loamly.iife.global.js.map