@loamly/tracker 1.6.0 → 1.7.0

package/dist/index.cjs

@@ -32,7 +32,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/config.ts
-var VERSION = "1.6.0";
+var VERSION = "1.7.0";
 var DEFAULT_CONFIG = {
   apiHost: "https://app.loamly.ai",
   endpoints: {
@@ -209,6 +209,322 @@ 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/utils.ts
 function generateUUID() {
   if (typeof crypto !== "undefined" && crypto.randomUUID) {
@@ -294,6 +610,8 @@ var sessionId = null;
 var sessionStartTime = null;
 var navigationTiming = null;
 var aiDetection = null;
+var behavioralClassifier = null;
+var behavioralMLResult = null;
 function log(...args) {
   if (debugMode) {
     console.log("[Loamly]", ...args);
@@ -333,6 +651,9 @@ function init(userConfig = {}) {
   if (!userConfig.disableBehavioral) {
     setupBehavioralTracking();
   }
+  behavioralClassifier = new BehavioralClassifier(1e4);
+  behavioralClassifier.setOnClassify(handleBehavioralClassification);
+  setupBehavioralMLTracking();
   log("Initialization complete");
 }
 function pageview(customUrl) {
@@ -514,6 +835,89 @@ 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
+  });
+  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 getCurrentSessionId() {
   return sessionId;
 }
@@ -526,6 +930,9 @@ function getAIDetectionResult() {
 function getNavigationTimingResult() {
   return navigationTiming;
 }
+function getBehavioralMLResult() {
+  return behavioralMLResult;
+}
 function isTrackerInitialized() {
   return initialized;
 }
@@ -537,6 +944,8 @@ function reset() {
   sessionStartTime = null;
   navigationTiming = null;
   aiDetection = null;
+  behavioralClassifier = null;
+  behavioralMLResult = null;
   try {
     sessionStorage.removeItem("loamly_session");
     sessionStorage.removeItem("loamly_start");
@@ -557,6 +966,7 @@ var loamly = {
   getVisitorId: getCurrentVisitorId,
   getAIDetection: getAIDetectionResult,
   getNavigationTiming: getNavigationTimingResult,
+  getBehavioralML: getBehavioralMLResult,
   isInitialized: isTrackerInitialized,
   reset,
   debug: setDebug