@loamly/tracker 1.6.0 → 1.8.0

package/dist/loamly.iife.global.js

@@ -26,7 +26,7 @@ var Loamly = (() => {
   });
 
   // src/config.ts
-  var VERSION = "1.6.0";
+  var VERSION = "1.8.0";
   var DEFAULT_CONFIG = {
     apiHost: "https://app.loamly.ai",
     endpoints: {
@@ -191,6 +191,467 @@ var Loamly = (() => {
     }
   }
 
+  // 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) {
@@ -276,6 +737,10 @@ var Loamly = (() => {
   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);
@@ -315,6 +780,16 @@ var Loamly = (() => {
     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) {
@@ -496,6 +971,116 @@ var Loamly = (() => {
       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;
   }
@@ -508,6 +1093,12 @@ var Loamly = (() => {
   function getNavigationTimingResult() {
     return navigationTiming;
   }
+  function getBehavioralMLResult() {
+    return behavioralMLResult;
+  }
+  function getFocusBlurResult() {
+    return focusBlurResult;
+  }
   function isTrackerInitialized() {
     return initialized;
   }
@@ -519,6 +1110,10 @@ var Loamly = (() => {
     sessionStartTime = null;
     navigationTiming = null;
     aiDetection = null;
+    behavioralClassifier = null;
+    behavioralMLResult = null;
+    focusBlurAnalyzer = null;
+    focusBlurResult = null;
     try {
       sessionStorage.removeItem("loamly_session");
       sessionStorage.removeItem("loamly_start");
@@ -539,6 +1134,8 @@ var Loamly = (() => {
     getVisitorId: getCurrentVisitorId,
     getAIDetection: getAIDetectionResult,
     getNavigationTiming: getNavigationTimingResult,
+    getBehavioralML: getBehavioralMLResult,
+    getFocusBlur: getFocusBlurResult,
     isInitialized: isTrackerInitialized,
     reset,
     debug: setDebug
@@ -591,4 +1188,11 @@ var Loamly = (() => {
   var browser_default = loamly;
   return __toCommonJS(browser_exports);
 })();
+/**
+ * Loamly Tracker Configuration
+ * 
+ * @module @loamly/tracker
+ * @license MIT
+ * @see https://github.com/loamly/loamly
+ */
 //# sourceMappingURL=loamly.iife.global.js.map