@loamly/tracker 1.6.0 → 1.8.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/config.ts
-var VERSION = "1.6.0";
+var VERSION = "1.8.0";
 var DEFAULT_CONFIG = {
   apiHost: "https://app.loamly.ai",
   endpoints: {
@@ -176,6 +176,467 @@ function detectAIFromUTM(url) {
   }
 }
 
+// src/detection/behavioral-classifier.ts
+var NAIVE_BAYES_WEIGHTS = {
+  human: {
+    time_to_first_click_delayed: 0.85,
+    time_to_first_click_normal: 0.75,
+    time_to_first_click_fast: 0.5,
+    time_to_first_click_immediate: 0.25,
+    scroll_speed_variable: 0.8,
+    scroll_speed_erratic: 0.7,
+    scroll_speed_uniform: 0.35,
+    scroll_speed_none: 0.45,
+    nav_timing_click: 0.75,
+    nav_timing_unknown: 0.55,
+    nav_timing_paste: 0.35,
+    has_referrer: 0.7,
+    no_referrer: 0.45,
+    homepage_landing: 0.65,
+    deep_landing: 0.5,
+    mouse_movement_curved: 0.9,
+    mouse_movement_linear: 0.3,
+    mouse_movement_none: 0.4,
+    form_fill_normal: 0.85,
+    form_fill_fast: 0.6,
+    form_fill_instant: 0.2,
+    focus_blur_normal: 0.75,
+    focus_blur_rapid: 0.45
+  },
+  ai_influenced: {
+    time_to_first_click_immediate: 0.75,
+    time_to_first_click_fast: 0.55,
+    time_to_first_click_normal: 0.4,
+    time_to_first_click_delayed: 0.35,
+    scroll_speed_none: 0.55,
+    scroll_speed_uniform: 0.7,
+    scroll_speed_variable: 0.35,
+    scroll_speed_erratic: 0.4,
+    nav_timing_paste: 0.75,
+    nav_timing_unknown: 0.5,
+    nav_timing_click: 0.35,
+    no_referrer: 0.65,
+    has_referrer: 0.4,
+    deep_landing: 0.6,
+    homepage_landing: 0.45,
+    mouse_movement_none: 0.6,
+    mouse_movement_linear: 0.75,
+    mouse_movement_curved: 0.25,
+    form_fill_instant: 0.8,
+    form_fill_fast: 0.55,
+    form_fill_normal: 0.3,
+    focus_blur_rapid: 0.6,
+    focus_blur_normal: 0.4
+  }
+};
+var PRIORS = {
+  human: 0.85,
+  ai_influenced: 0.15
+};
+var DEFAULT_WEIGHT = 0.5;
+var BehavioralClassifier = class {
+  /**
+   * Create a new classifier
+   * @param minSessionTimeMs Minimum session time before classification (default: 10s)
+   */
+  constructor(minSessionTimeMs = 1e4) {
+    this.classified = false;
+    this.result = null;
+    this.onClassify = null;
+    this.minSessionTime = minSessionTimeMs;
+    this.data = {
+      firstClickTime: null,
+      scrollEvents: [],
+      mouseEvents: [],
+      formEvents: [],
+      focusBlurEvents: [],
+      startTime: Date.now()
+    };
+  }
+  /**
+   * Set callback for when classification completes
+   */
+  setOnClassify(callback) {
+    this.onClassify = callback;
+  }
+  /**
+   * Record a click event
+   */
+  recordClick() {
+    if (this.data.firstClickTime === null) {
+      this.data.firstClickTime = Date.now();
+    }
+    this.checkAndClassify();
+  }
+  /**
+   * Record a scroll event
+   */
+  recordScroll(position) {
+    this.data.scrollEvents.push({ time: Date.now(), position });
+    if (this.data.scrollEvents.length > 50) {
+      this.data.scrollEvents = this.data.scrollEvents.slice(-50);
+    }
+    this.checkAndClassify();
+  }
+  /**
+   * Record mouse movement
+   */
+  recordMouse(x, y) {
+    this.data.mouseEvents.push({ time: Date.now(), x, y });
+    if (this.data.mouseEvents.length > 100) {
+      this.data.mouseEvents = this.data.mouseEvents.slice(-100);
+    }
+    this.checkAndClassify();
+  }
+  /**
+   * Record form field interaction start
+   */
+  recordFormStart(fieldId) {
+    const existing = this.data.formEvents.find((e) => e.fieldId === fieldId && e.endTime === 0);
+    if (!existing) {
+      this.data.formEvents.push({ fieldId, startTime: Date.now(), endTime: 0 });
+    }
+  }
+  /**
+   * Record form field interaction end
+   */
+  recordFormEnd(fieldId) {
+    const event = this.data.formEvents.find((e) => e.fieldId === fieldId && e.endTime === 0);
+    if (event) {
+      event.endTime = Date.now();
+    }
+    this.checkAndClassify();
+  }
+  /**
+   * Record focus/blur event
+   */
+  recordFocusBlur(type) {
+    this.data.focusBlurEvents.push({ type, time: Date.now() });
+    if (this.data.focusBlurEvents.length > 20) {
+      this.data.focusBlurEvents = this.data.focusBlurEvents.slice(-20);
+    }
+  }
+  /**
+   * Check if we have enough data and classify
+   */
+  checkAndClassify() {
+    if (this.classified) return;
+    const sessionDuration = Date.now() - this.data.startTime;
+    if (sessionDuration < this.minSessionTime) return;
+    const hasData = this.data.scrollEvents.length >= 2 || this.data.mouseEvents.length >= 5 || this.data.firstClickTime !== null;
+    if (!hasData) return;
+    this.classify();
+  }
+  /**
+   * Force classification (for beforeunload)
+   */
+  forceClassify() {
+    if (this.classified) return this.result;
+    return this.classify();
+  }
+  /**
+   * Perform classification
+   */
+  classify() {
+    const sessionDuration = Date.now() - this.data.startTime;
+    const signals = this.extractSignals();
+    let humanLogProb = Math.log(PRIORS.human);
+    let aiLogProb = Math.log(PRIORS.ai_influenced);
+    for (const signal of signals) {
+      const humanWeight = NAIVE_BAYES_WEIGHTS.human[signal] ?? DEFAULT_WEIGHT;
+      const aiWeight = NAIVE_BAYES_WEIGHTS.ai_influenced[signal] ?? DEFAULT_WEIGHT;
+      humanLogProb += Math.log(humanWeight);
+      aiLogProb += Math.log(aiWeight);
+    }
+    const maxLog = Math.max(humanLogProb, aiLogProb);
+    const humanExp = Math.exp(humanLogProb - maxLog);
+    const aiExp = Math.exp(aiLogProb - maxLog);
+    const total = humanExp + aiExp;
+    const humanProbability = humanExp / total;
+    const aiProbability = aiExp / total;
+    let classification;
+    let confidence;
+    if (humanProbability > 0.6) {
+      classification = "human";
+      confidence = humanProbability;
+    } else if (aiProbability > 0.6) {
+      classification = "ai_influenced";
+      confidence = aiProbability;
+    } else {
+      classification = "uncertain";
+      confidence = Math.max(humanProbability, aiProbability);
+    }
+    this.result = {
+      classification,
+      humanProbability,
+      aiProbability,
+      confidence,
+      signals,
+      timestamp: Date.now(),
+      sessionDurationMs: sessionDuration
+    };
+    this.classified = true;
+    if (this.onClassify) {
+      this.onClassify(this.result);
+    }
+    return this.result;
+  }
+  /**
+   * Extract behavioral signals from collected data
+   */
+  extractSignals() {
+    const signals = [];
+    if (this.data.firstClickTime !== null) {
+      const timeToClick = this.data.firstClickTime - this.data.startTime;
+      if (timeToClick < 500) {
+        signals.push("time_to_first_click_immediate");
+      } else if (timeToClick < 2e3) {
+        signals.push("time_to_first_click_fast");
+      } else if (timeToClick < 1e4) {
+        signals.push("time_to_first_click_normal");
+      } else {
+        signals.push("time_to_first_click_delayed");
+      }
+    }
+    if (this.data.scrollEvents.length === 0) {
+      signals.push("scroll_speed_none");
+    } else if (this.data.scrollEvents.length >= 3) {
+      const scrollDeltas = [];
+      for (let i = 1; i < this.data.scrollEvents.length; i++) {
+        const delta = this.data.scrollEvents[i].time - this.data.scrollEvents[i - 1].time;
+        scrollDeltas.push(delta);
+      }
+      const mean = scrollDeltas.reduce((a, b) => a + b, 0) / scrollDeltas.length;
+      const variance = scrollDeltas.reduce((sum, d) => sum + Math.pow(d - mean, 2), 0) / scrollDeltas.length;
+      const stdDev = Math.sqrt(variance);
+      const cv = mean > 0 ? stdDev / mean : 0;
+      if (cv < 0.2) {
+        signals.push("scroll_speed_uniform");
+      } else if (cv < 0.6) {
+        signals.push("scroll_speed_variable");
+      } else {
+        signals.push("scroll_speed_erratic");
+      }
+    }
+    if (this.data.mouseEvents.length === 0) {
+      signals.push("mouse_movement_none");
+    } else if (this.data.mouseEvents.length >= 10) {
+      const n = Math.min(this.data.mouseEvents.length, 20);
+      const recentMouse = this.data.mouseEvents.slice(-n);
+      let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
+      for (const event of recentMouse) {
+        sumX += event.x;
+        sumY += event.y;
+        sumXY += event.x * event.y;
+        sumX2 += event.x * event.x;
+      }
+      const denominator = n * sumX2 - sumX * sumX;
+      const slope = denominator !== 0 ? (n * sumXY - sumX * sumY) / denominator : 0;
+      const intercept = (sumY - slope * sumX) / n;
+      let ssRes = 0, ssTot = 0;
+      const yMean = sumY / n;
+      for (const event of recentMouse) {
+        const yPred = slope * event.x + intercept;
+        ssRes += Math.pow(event.y - yPred, 2);
+        ssTot += Math.pow(event.y - yMean, 2);
+      }
+      const r2 = ssTot !== 0 ? 1 - ssRes / ssTot : 0;
+      if (r2 > 0.95) {
+        signals.push("mouse_movement_linear");
+      } else {
+        signals.push("mouse_movement_curved");
+      }
+    }
+    const completedForms = this.data.formEvents.filter((e) => e.endTime > 0);
+    if (completedForms.length > 0) {
+      const avgFillTime = completedForms.reduce((sum, e) => sum + (e.endTime - e.startTime), 0) / completedForms.length;
+      if (avgFillTime < 100) {
+        signals.push("form_fill_instant");
+      } else if (avgFillTime < 500) {
+        signals.push("form_fill_fast");
+      } else {
+        signals.push("form_fill_normal");
+      }
+    }
+    if (this.data.focusBlurEvents.length >= 4) {
+      const recentFB = this.data.focusBlurEvents.slice(-10);
+      const intervals = [];
+      for (let i = 1; i < recentFB.length; i++) {
+        intervals.push(recentFB[i].time - recentFB[i - 1].time);
+      }
+      const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+      if (avgInterval < 1e3) {
+        signals.push("focus_blur_rapid");
+      } else {
+        signals.push("focus_blur_normal");
+      }
+    }
+    return signals;
+  }
+  /**
+   * Add context signals (set by tracker from external data)
+   */
+  addContextSignal(_signal) {
+  }
+  /**
+   * Get current result (null if not yet classified)
+   */
+  getResult() {
+    return this.result;
+  }
+  /**
+   * Check if classification has been performed
+   */
+  hasClassified() {
+    return this.classified;
+  }
+};
+
+// src/detection/focus-blur.ts
+var FocusBlurAnalyzer = class {
+  constructor() {
+    this.sequence = [];
+    this.firstInteractionTime = null;
+    this.analyzed = false;
+    this.result = null;
+    this.pageLoadTime = performance.now();
+  }
+  /**
+   * Initialize event tracking
+   * Must be called after DOM is ready
+   */
+  initTracking() {
+    document.addEventListener("focus", (e) => {
+      this.recordEvent("focus", e.target);
+    }, true);
+    document.addEventListener("blur", (e) => {
+      this.recordEvent("blur", e.target);
+    }, true);
+    window.addEventListener("focus", () => {
+      this.recordEvent("window_focus", null);
+    });
+    window.addEventListener("blur", () => {
+      this.recordEvent("window_blur", null);
+    });
+    const recordFirstInteraction = () => {
+      if (this.firstInteractionTime === null) {
+        this.firstInteractionTime = performance.now();
+      }
+    };
+    document.addEventListener("click", recordFirstInteraction, { once: true, passive: true });
+    document.addEventListener("keydown", recordFirstInteraction, { once: true, passive: true });
+  }
+  /**
+   * Record a focus/blur event
+   */
+  recordEvent(type, target) {
+    const event = {
+      type,
+      target: target?.tagName || "WINDOW",
+      timestamp: performance.now()
+    };
+    this.sequence.push(event);
+    if (this.sequence.length > 20) {
+      this.sequence = this.sequence.slice(-20);
+    }
+  }
+  /**
+   * Analyze the focus/blur sequence for paste patterns
+   */
+  analyze() {
+    if (this.analyzed && this.result) {
+      return this.result;
+    }
+    const signals = [];
+    let confidence = 0;
+    const earlyEvents = this.sequence.filter((e) => e.timestamp < this.pageLoadTime + 500);
+    const hasEarlyWindowFocus = earlyEvents.some((e) => e.type === "window_focus");
+    if (hasEarlyWindowFocus) {
+      signals.push("early_window_focus");
+      confidence += 0.15;
+    }
+    const hasEarlyBodyFocus = earlyEvents.some(
+      (e) => e.type === "focus" && e.target === "BODY"
+    );
+    if (hasEarlyBodyFocus) {
+      signals.push("early_body_focus");
+      confidence += 0.15;
+    }
+    const hasLinkFocus = this.sequence.some(
+      (e) => e.type === "focus" && e.target === "A"
+    );
+    if (!hasLinkFocus) {
+      signals.push("no_link_focus");
+      confidence += 0.1;
+    }
+    const firstFocus = this.sequence.find((e) => e.type === "focus");
+    if (firstFocus && (firstFocus.target === "BODY" || firstFocus.target === "HTML")) {
+      signals.push("first_focus_body");
+      confidence += 0.1;
+    }
+    const windowEvents = this.sequence.filter(
+      (e) => e.type === "window_focus" || e.type === "window_blur"
+    );
+    if (windowEvents.length <= 2) {
+      signals.push("minimal_window_switches");
+      confidence += 0.05;
+    }
+    if (this.firstInteractionTime !== null) {
+      const timeToInteraction = this.firstInteractionTime - this.pageLoadTime;
+      if (timeToInteraction > 3e3) {
+        signals.push("delayed_first_interaction");
+        confidence += 0.1;
+      }
+    }
+    confidence = Math.min(confidence, 0.65);
+    let navType;
+    if (confidence >= 0.35) {
+      navType = "likely_paste";
+    } else if (signals.length === 0) {
+      navType = "unknown";
+    } else {
+      navType = "likely_click";
+    }
+    this.result = {
+      nav_type: navType,
+      confidence,
+      signals,
+      sequence: this.sequence.slice(-10),
+      time_to_first_interaction_ms: this.firstInteractionTime ? Math.round(this.firstInteractionTime - this.pageLoadTime) : null
+    };
+    this.analyzed = true;
+    return this.result;
+  }
+  /**
+   * Get current result (analyze if not done)
+   */
+  getResult() {
+    return this.analyze();
+  }
+  /**
+   * Check if analysis has been performed
+   */
+  hasAnalyzed() {
+    return this.analyzed;
+  }
+  /**
+   * Get the raw sequence for debugging
+   */
+  getSequence() {
+    return [...this.sequence];
+  }
+  /**
+   * Reset the analyzer
+   */
+  reset() {
+    this.sequence = [];
+    this.pageLoadTime = performance.now();
+    this.firstInteractionTime = null;
+    this.analyzed = false;
+    this.result = null;
+  }
+};
+
 // src/utils.ts
 function generateUUID() {
   if (typeof crypto !== "undefined" && crypto.randomUUID) {
@@ -261,6 +722,10 @@ var sessionId = null;
 var sessionStartTime = null;
 var navigationTiming = null;
 var aiDetection = null;
+var behavioralClassifier = null;
+var behavioralMLResult = null;
+var focusBlurAnalyzer = null;
+var focusBlurResult = null;
 function log(...args) {
   if (debugMode) {
     console.log("[Loamly]", ...args);
@@ -300,6 +765,16 @@ function init(userConfig = {}) {
   if (!userConfig.disableBehavioral) {
     setupBehavioralTracking();
   }
+  behavioralClassifier = new BehavioralClassifier(1e4);
+  behavioralClassifier.setOnClassify(handleBehavioralClassification);
+  setupBehavioralMLTracking();
+  focusBlurAnalyzer = new FocusBlurAnalyzer();
+  focusBlurAnalyzer.initTracking();
+  setTimeout(() => {
+    if (focusBlurAnalyzer) {
+      handleFocusBlurAnalysis(focusBlurAnalyzer.analyze());
+    }
+  }, 5e3);
   log("Initialization complete");
 }
 function pageview(customUrl) {
@@ -481,6 +956,116 @@ function sendBehavioralEvent(eventType, data) {
     body: JSON.stringify(payload)
   });
 }
+function setupBehavioralMLTracking() {
+  if (!behavioralClassifier) return;
+  let mouseSampleCount = 0;
+  document.addEventListener("mousemove", (e) => {
+    mouseSampleCount++;
+    if (mouseSampleCount % 10 === 0 && behavioralClassifier) {
+      behavioralClassifier.recordMouse(e.clientX, e.clientY);
+    }
+  }, { passive: true });
+  document.addEventListener("click", () => {
+    if (behavioralClassifier) {
+      behavioralClassifier.recordClick();
+    }
+  }, { passive: true });
+  let lastScrollY = 0;
+  document.addEventListener("scroll", () => {
+    const currentY = window.scrollY;
+    if (Math.abs(currentY - lastScrollY) > 50 && behavioralClassifier) {
+      lastScrollY = currentY;
+      behavioralClassifier.recordScroll(currentY);
+    }
+  }, { passive: true });
+  document.addEventListener("focusin", (e) => {
+    if (behavioralClassifier) {
+      behavioralClassifier.recordFocusBlur("focus");
+      const target = e.target;
+      if (target.tagName === "INPUT" || target.tagName === "TEXTAREA") {
+        behavioralClassifier.recordFormStart(target.id || target.getAttribute("name") || "unknown");
+      }
+    }
+  }, { passive: true });
+  document.addEventListener("focusout", (e) => {
+    if (behavioralClassifier) {
+      behavioralClassifier.recordFocusBlur("blur");
+      const target = e.target;
+      if (target.tagName === "INPUT" || target.tagName === "TEXTAREA") {
+        behavioralClassifier.recordFormEnd(target.id || target.getAttribute("name") || "unknown");
+      }
+    }
+  }, { passive: true });
+  window.addEventListener("beforeunload", () => {
+    if (behavioralClassifier && !behavioralClassifier.hasClassified()) {
+      const result = behavioralClassifier.forceClassify();
+      if (result) {
+        handleBehavioralClassification(result);
+      }
+    }
+  });
+  setTimeout(() => {
+    if (behavioralClassifier && !behavioralClassifier.hasClassified()) {
+      behavioralClassifier.forceClassify();
+    }
+  }, 3e4);
+}
+function handleBehavioralClassification(result) {
+  log("Behavioral ML classification:", result);
+  behavioralMLResult = {
+    classification: result.classification,
+    humanProbability: result.humanProbability,
+    aiProbability: result.aiProbability,
+    confidence: result.confidence,
+    signals: result.signals,
+    sessionDurationMs: result.sessionDurationMs
+  };
+  sendBehavioralEvent("ml_classification", {
+    classification: result.classification,
+    human_probability: result.humanProbability,
+    ai_probability: result.aiProbability,
+    confidence: result.confidence,
+    signals: result.signals,
+    session_duration_ms: result.sessionDurationMs,
+    navigation_timing: navigationTiming,
+    ai_detection: aiDetection,
+    focus_blur: focusBlurResult
+  });
+  if (result.classification === "ai_influenced" && result.confidence >= 0.7) {
+    aiDetection = {
+      isAI: true,
+      confidence: result.confidence,
+      method: "behavioral"
+    };
+    log("AI detection updated from behavioral ML:", aiDetection);
+  }
+}
+function handleFocusBlurAnalysis(result) {
+  log("Focus/blur analysis:", result);
+  focusBlurResult = {
+    navType: result.nav_type,
+    confidence: result.confidence,
+    signals: result.signals,
+    timeToFirstInteractionMs: result.time_to_first_interaction_ms
+  };
+  sendBehavioralEvent("focus_blur_analysis", {
+    nav_type: result.nav_type,
+    confidence: result.confidence,
+    signals: result.signals,
+    time_to_first_interaction_ms: result.time_to_first_interaction_ms,
+    sequence_length: result.sequence.length
+  });
+  if (result.nav_type === "likely_paste" && result.confidence >= 0.4) {
+    if (!aiDetection || aiDetection.confidence < result.confidence) {
+      aiDetection = {
+        isAI: true,
+        confidence: result.confidence,
+        method: "behavioral"
+      };
+      log("AI detection updated from focus/blur analysis:", aiDetection);
+    }
+  }
+}
 function getCurrentSessionId() {
   return sessionId;
 }
@@ -493,6 +1078,12 @@ function getAIDetectionResult() {
 function getNavigationTimingResult() {
   return navigationTiming;
 }
+function getBehavioralMLResult() {
+  return behavioralMLResult;
+}
+function getFocusBlurResult() {
+  return focusBlurResult;
+}
 function isTrackerInitialized() {
   return initialized;
 }
@@ -504,6 +1095,10 @@ function reset() {
   sessionStartTime = null;
   navigationTiming = null;
   aiDetection = null;
+  behavioralClassifier = null;
+  behavioralMLResult = null;
+  focusBlurAnalyzer = null;
+  focusBlurResult = null;
   try {
     sessionStorage.removeItem("loamly_session");
     sessionStorage.removeItem("loamly_start");
@@ -524,20 +1119,247 @@ var loamly = {
   getVisitorId: getCurrentVisitorId,
   getAIDetection: getAIDetectionResult,
   getNavigationTiming: getNavigationTimingResult,
+  getBehavioralML: getBehavioralMLResult,
+  getFocusBlur: getFocusBlurResult,
   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;
+}
 export {
   AI_BOT_PATTERNS,
   AI_PLATFORMS,
+  AgenticBrowserAnalyzer,
   VERSION,
+  createAgenticAnalyzer,
   loamly as default,
   detectAIFromReferrer,
   detectAIFromUTM,
   detectNavigationType,
   loamly
 };
+/**
+ * Loamly Tracker Configuration
+ * 
+ * @module @loamly/tracker
+ * @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
+ */
 /**
  * Loamly Tracker
  * 
@@ -545,7 +1367,9 @@ export {
  * See what AI tells your customers — and track when they click.
  * 
  * @module @loamly/tracker
+ * @version 1.8.0
  * @license MIT
+ * @see https://github.com/loamly/loamly
  * @see https://loamly.ai
  */
 //# sourceMappingURL=index.mjs.map