@loamly/tracker 2.1.1 → 2.4.0

package/dist/loamly.iife.global.js

@@ -25,633 +25,584 @@ var Loamly = (() => {
     loamly: () => loamly
   });
 
-  // src/config.ts
-  var VERSION = "2.1.1";
+  // src/behavioral/form-tracker.ts
   var DEFAULT_CONFIG = {
-    apiHost: "https://app.loamly.ai",
-    endpoints: {
-      visit: "/api/ingest/visit",
-      behavioral: "/api/ingest/behavioral",
-      session: "/api/ingest/session",
-      resolve: "/api/tracker/resolve",
-      health: "/api/tracker/health",
-      ping: "/api/tracker/ping"
-    },
-    pingInterval: 3e4,
-    // 30 seconds
-    batchSize: 10,
-    batchTimeout: 5e3,
-    sessionTimeout: 18e5,
-    // 30 minutes
-    maxTextLength: 100,
-    timeSpentThresholdMs: 5e3
-    // Only send time_spent when delta >= 5 seconds
-  };
-  var AI_PLATFORMS = {
-    "chatgpt.com": "chatgpt",
-    "chat.openai.com": "chatgpt",
-    "claude.ai": "claude",
-    "perplexity.ai": "perplexity",
-    "bard.google.com": "bard",
-    "gemini.google.com": "gemini",
-    "copilot.microsoft.com": "copilot",
-    "github.com/copilot": "github-copilot",
-    "you.com": "you",
-    "phind.com": "phind",
-    "poe.com": "poe"
+    sensitiveFields: [
+      "password",
+      "pwd",
+      "pass",
+      "credit",
+      "card",
+      "cvv",
+      "cvc",
+      "ssn",
+      "social",
+      "secret",
+      "token",
+      "key",
+      "pin",
+      "security",
+      "answer"
+    ],
+    trackableFields: [
+      "email",
+      "name",
+      "phone",
+      "company",
+      "first",
+      "last",
+      "city",
+      "country",
+      "domain",
+      "website",
+      "url",
+      "organization"
+    ],
+    thankYouPatterns: [
+      /thank[-_]?you/i,
+      /success/i,
+      /confirmation/i,
+      /submitted/i,
+      /complete/i
+    ],
+    // LOA-482: Enable field value capture by default
+    captureFieldValues: true,
+    maxFieldValueLength: 200
   };
-
-  // src/detection/navigation-timing.ts
-  function detectNavigationType() {
-    try {
-      const entries = performance.getEntriesByType("navigation");
-      if (!entries || entries.length === 0) {
-        return { nav_type: "unknown", confidence: 0, signals: ["no_timing_data"] };
-      }
-      const nav = entries[0];
-      const signals = [];
-      let pasteScore = 0;
-      const fetchStartDelta = nav.fetchStart - nav.startTime;
-      if (fetchStartDelta < 5) {
-        pasteScore += 0.25;
-        signals.push("instant_fetch_start");
-      } else if (fetchStartDelta < 20) {
-        pasteScore += 0.15;
-        signals.push("fast_fetch_start");
-      }
-      const dnsTime = nav.domainLookupEnd - nav.domainLookupStart;
-      if (dnsTime === 0) {
-        pasteScore += 0.15;
-        signals.push("no_dns_lookup");
-      }
-      const connectTime = nav.connectEnd - nav.connectStart;
-      if (connectTime === 0) {
-        pasteScore += 0.15;
-        signals.push("no_tcp_connect");
-      }
-      if (nav.redirectCount === 0) {
-        pasteScore += 0.1;
-        signals.push("no_redirects");
-      }
-      const timingVariance = calculateTimingVariance(nav);
-      if (timingVariance < 10) {
-        pasteScore += 0.15;
-        signals.push("uniform_timing");
-      }
-      if (!document.referrer || document.referrer === "") {
-        pasteScore += 0.1;
-        signals.push("no_referrer");
-      }
-      const confidence = Math.min(pasteScore, 1);
-      const nav_type = pasteScore >= 0.5 ? "likely_paste" : "likely_click";
-      return {
-        nav_type,
-        confidence: Math.round(confidence * 1e3) / 1e3,
-        signals
-      };
-    } catch {
-      return { nav_type: "unknown", confidence: 0, signals: ["detection_error"] };
-    }
-  }
-  function calculateTimingVariance(nav) {
-    const timings = [
-      nav.fetchStart - nav.startTime,
-      nav.domainLookupEnd - nav.domainLookupStart,
-      nav.connectEnd - nav.connectStart,
-      nav.responseStart - nav.requestStart
-    ].filter((t) => t >= 0);
-    if (timings.length === 0) return 100;
-    const mean = timings.reduce((a, b) => a + b, 0) / timings.length;
-    const variance = timings.reduce((sum, t) => sum + Math.pow(t - mean, 2), 0) / timings.length;
-    return Math.sqrt(variance);
-  }
-
-  // src/detection/referrer.ts
-  function detectAIFromReferrer(referrer) {
-    if (!referrer) {
-      return null;
-    }
-    try {
-      const url = new URL(referrer);
-      const hostname = url.hostname.toLowerCase();
-      for (const [pattern, platform] of Object.entries(AI_PLATFORMS)) {
-        if (hostname.includes(pattern) || referrer.includes(pattern)) {
-          return {
-            isAI: true,
-            platform,
-            confidence: 0.95,
-            // High confidence when referrer matches
-            method: "referrer"
-          };
+  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)
+          });
         }
-      }
-      return null;
-    } catch {
-      for (const [pattern, platform] of Object.entries(AI_PLATFORMS)) {
-        if (referrer.toLowerCase().includes(pattern.toLowerCase())) {
-          return {
-            isAI: true,
-            platform,
-            confidence: 0.85,
-            method: "referrer"
-          };
+        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()
+          });
         }
-      }
-      return null;
-    }
-  }
-  function detectAIFromUTM(url) {
-    try {
-      const params = new URL(url).searchParams;
-      const utmSource = params.get("utm_source")?.toLowerCase();
-      if (utmSource) {
-        for (const [pattern, platform] of Object.entries(AI_PLATFORMS)) {
-          if (utmSource.includes(pattern.split(".")[0])) {
-            return {
-              isAI: true,
-              platform,
-              confidence: 0.99,
-              // Very high confidence from explicit UTM
-              method: "referrer"
-            };
+      };
+      this.handleSubmit = (e) => {
+        const form = e.target;
+        if (!form || form.tagName !== "FORM") return;
+        const formId = this.getFormId(form);
+        const startTime = this.formStartTimes.get(formId);
+        const { fields, emailSubmitted } = this.captureFormFields(form);
+        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,
+          submit_source: "submit",
+          fields: fields.length > 0 ? fields : void 0,
+          email_submitted: emailSubmitted
+        });
+      };
+      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);
+            const { fields, emailSubmitted } = this.captureFormFields(form);
+            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,
+              submit_source: "click",
+              fields: fields.length > 0 ? fields : void 0,
+              email_submitted: emailSubmitted
+            });
           }
         }
-        if (utmSource.includes("ai") || utmSource.includes("llm") || utmSource.includes("chatbot")) {
-          return {
-            isAI: true,
-            platform: utmSource,
-            confidence: 0.9,
-            method: "referrer"
-          };
+        if (target.closest('[data-qa="submit-button"]')) {
+          this.emitEvent({
+            event_type: "form_submit",
+            form_id: "typeform_embed",
+            form_type: "typeform",
+            is_conversion: true,
+            submit_source: "click"
+          });
         }
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
-  // 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();
+      };
+      this.config = {
+        ...DEFAULT_CONFIG,
+        ...config2,
+        sensitiveFields: [
+          ...DEFAULT_CONFIG.sensitiveFields,
+          ...config2.sensitiveFields || []
+        ]
+      };
     }
     /**
-     * Record focus/blur event
+     * Start tracking forms
      */
-    recordFocusBlur(type) {
-      this.data.focusBlurEvents.push({ type, time: Date.now() });
-      if (this.data.focusBlurEvents.length > 20) {
-        this.data.focusBlurEvents = this.data.focusBlurEvents.slice(-20);
-      }
+    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();
     }
     /**
-     * Check if we have enough data and classify
+     * Stop tracking
      */
-    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();
+    stop() {
+      document.removeEventListener("focusin", this.handleFocusIn);
+      document.removeEventListener("submit", this.handleSubmit);
+      document.removeEventListener("click", this.handleClick);
+      this.mutationObserver?.disconnect();
     }
     /**
-     * Force classification (for beforeunload)
+     * Get forms that had interaction
      */
-    forceClassify() {
-      if (this.classified) return this.result;
-      return this.classify();
+    getInteractedForms() {
+      return Array.from(this.interactedForms);
     }
     /**
-     * Perform classification
+     * LOA-482: Capture form field values with privacy-safe sanitization
+     * - Never captures sensitive fields (password, credit card, etc.)
+     * - Truncates values to maxFieldValueLength
+     * - Extracts email if found
      */
-    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);
+    captureFormFields(form) {
+      const fields = [];
+      let emailSubmitted;
+      if (!this.config.captureFieldValues) {
+        return { fields, emailSubmitted };
       }
-      this.result = {
-        classification,
-        humanProbability,
-        aiProbability,
-        confidence,
-        signals,
-        timestamp: Date.now(),
-        sessionDurationMs: sessionDuration
-      };
-      this.classified = true;
-      if (this.onClassify) {
-        this.onClassify(this.result);
+      try {
+        const formData = new FormData(form);
+        for (const [name, value] of formData.entries()) {
+          if (this.isSensitiveField(name)) {
+            continue;
+          }
+          const input = form.elements.namedItem(name);
+          const inputType = input?.type || "text";
+          if (inputType === "file" || value instanceof File) {
+            continue;
+          }
+          const stringValue = String(value);
+          if (this.isEmailField(name, stringValue)) {
+            emailSubmitted = stringValue.substring(0, 254);
+          }
+          const truncatedValue = stringValue.length > this.config.maxFieldValueLength ? stringValue.substring(0, this.config.maxFieldValueLength) + "..." : stringValue;
+          fields.push({
+            name: this.sanitizeFieldName(name),
+            type: inputType,
+            value: truncatedValue
+          });
+        }
+      } catch (err) {
+        console.warn("[Loamly] Failed to capture form fields:", err);
       }
-      return this.result;
+      return { fields, emailSubmitted };
     }
     /**
-     * Extract behavioral signals from collected data
+     * Check if a field contains an email
      */
-    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");
+    isEmailField(fieldName, value) {
+      const lowerName = fieldName.toLowerCase();
+      const isEmailName = lowerName.includes("email") || lowerName === "e-mail";
+      const isEmailValue = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+      return isEmailName && isEmailValue;
+    }
+    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");
+              }
+            }
+          }
         }
-      }
-      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);
+      });
+      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
+          });
         }
-        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");
+      }, { 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,
+            submit_source: "thank_you"
+          });
+          break;
         }
       }
-      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");
-        }
+    }
+    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";
       }
-      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 (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 (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");
-        }
+      if (element.tagName === "FORM") {
+        return "native";
       }
-      return signals;
+      return "unknown";
+    }
+    emitEvent(event) {
+      this.config.onFormEvent?.(event);
+    }
+  };
+
+  // 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();
     }
     /**
-     * Add context signals (set by tracker from external data)
+     * Start tracking scroll depth
      */
-    addContextSignal(_signal) {
+    start() {
+      window.addEventListener("scroll", this.handleScroll, { passive: true });
+      document.addEventListener("visibilitychange", this.handleVisibility);
+      this.checkScrollDepth();
     }
     /**
-     * Get current result (null if not yet classified)
+     * Stop tracking
      */
-    getResult() {
-      return this.result;
+    stop() {
+      window.removeEventListener("scroll", this.handleScroll);
+      document.removeEventListener("visibilitychange", this.handleVisibility);
     }
     /**
-     * Check if classification has been performed
+     * Get current max scroll depth
      */
-    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();
+    getMaxDepth() {
+      return this.maxDepth;
     }
     /**
-     * Initialize event tracking
-     * Must be called after DOM is ready
+     * Get reported chunks
      */
-    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 });
+    getReportedChunks() {
+      return Array.from(this.reportedChunks).sort((a, b) => a - b);
     }
     /**
-     * Record a focus/blur event
+     * Get final scroll event (for unload)
      */
-    recordEvent(type, target) {
-      const event = {
-        type,
-        target: target?.tagName || "WINDOW",
-        timestamp: performance.now()
+    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
       };
-      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;
+    checkScrollDepth() {
+      const scrollY = window.scrollY;
+      const viewportHeight = window.innerHeight;
+      const docHeight = document.documentElement.scrollHeight;
+      if (docHeight <= viewportHeight) {
+        this.updateDepth(100);
+        return;
       }
-      if (this.firstInteractionTime !== null) {
-        const timeToInteraction = this.firstInteractionTime - this.pageLoadTime;
-        if (timeToInteraction > 3e3) {
-          signals.push("delayed_first_interaction");
-          confidence += 0.1;
+      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);
         }
       }
-      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";
+    }
+    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;
       }
-      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
+      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.analyzed = true;
-      return this.result;
+      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;
     }
     /**
-     * Get current result (analyze if not done)
+     * Start tracking time
      */
-    getResult() {
-      return this.analyze();
+    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);
     }
     /**
-     * Check if analysis has been performed
+     * Stop tracking
      */
-    hasAnalyzed() {
-      return this.analyzed;
+    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 the raw sequence for debugging
+     * Get current time metrics
      */
-    getSequence() {
-      return [...this.sequence];
+    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
+      };
     }
     /**
-     * Reset the analyzer
+     * Get final metrics (for unload)
      */
-    reset() {
-      this.sequence = [];
-      this.pageLoadTime = performance.now();
-      this.firstInteractionTime = null;
-      this.analyzed = false;
-      this.result = null;
+    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/config.ts
+  var VERSION = "2.4.0";
+  var DEFAULT_CONFIG3 = {
+    apiHost: "https://app.loamly.ai",
+    endpoints: {
+      visit: "/api/ingest/visit",
+      behavioral: "/api/ingest/behavioral",
+      session: "/api/ingest/session",
+      resolve: "/api/tracker/resolve",
+      health: "/api/tracker/health",
+      ping: "/api/tracker/ping"
+    },
+    pingInterval: 3e4,
+    // 30 seconds
+    batchSize: 10,
+    batchTimeout: 5e3,
+    sessionTimeout: 18e5,
+    // 30 minutes
+    maxTextLength: 100,
+    timeSpentThresholdMs: 5e3
+    // Only send time_spent when delta >= 5 seconds
+  };
+  var AI_PLATFORMS = {
+    "chatgpt.com": "chatgpt",
+    "chat.openai.com": "chatgpt",
+    "claude.ai": "claude",
+    "perplexity.ai": "perplexity",
+    "bard.google.com": "bard",
+    "gemini.google.com": "gemini",
+    "copilot.microsoft.com": "copilot",
+    "github.com/copilot": "github-copilot",
+    "you.com": "you",
+    "phind.com": "phind",
+    "poe.com": "poe"
+  };
+
   // src/detection/agentic-browser.ts
   var CometDetector = class {
     constructor() {
@@ -834,772 +785,885 @@ var Loamly = (() => {
       };
     }
     /**
-     * Cleanup resources
+     * Cleanup resources
+     */
+    destroy() {
+      this.cometDetector.destroy();
+      this.mouseAnalyzer.destroy();
+    }
+  };
+
+  // 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
      */
-    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();
+    recordFocusBlur(type) {
+      this.data.focusBlurEvents.push({ type, time: Date.now() });
+      if (this.data.focusBlurEvents.length > 20) {
+        this.data.focusBlurEvents = this.data.focusBlurEvents.slice(-20);
+      }
     }
     /**
-     * Add event to queue
+     * Check if we have enough data and classify
      */
-    push(type, payload, headers) {
-      const event = {
-        id: this.generateId(),
-        type,
-        payload,
-        headers,
-        timestamp: Date.now(),
-        retries: 0
-      };
-      this.queue.push(event);
-      this.saveToStorage();
-      this.scheduleBatch();
+    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 flush all events immediately
+     * Force classification (for beforeunload)
      */
-    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();
-      }
+    forceClassify() {
+      if (this.classified) return this.result;
+      return this.classify();
     }
     /**
-     * Flush using sendBeacon (for unload events)
+     * Perform classification
      */
-    flushBeacon() {
-      if (this.queue.length === 0) return true;
-      const baseUrl = this.config.apiKey ? `${this.endpoint}?api_key=${encodeURIComponent(this.config.apiKey)}` : this.endpoint;
-      let allSent = true;
-      for (const event of this.queue) {
-        const payload = {
-          ...event.payload,
-          _queue_id: event.id,
-          _queue_timestamp: event.timestamp
-        };
-        const success = navigator.sendBeacon?.(baseUrl, JSON.stringify(payload)) ?? false;
-        if (!success) {
-          allSent = false;
-          break;
-        }
+    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);
       }
-      if (allSent) {
-        this.queue = [];
-        this.clearStorage();
+      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);
       }
-      return allSent;
+      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;
     }
     /**
-     * Get current queue length
+     * Extract behavioral signals from collected data
      */
-    get length() {
-      return this.queue.length;
-    }
-    scheduleBatch() {
-      if (this.batchTimer) return;
-      if (this.queue.length >= this.config.batchSize) {
-        this.flush();
-        return;
+    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");
+        }
       }
-      this.batchTimer = setTimeout(() => {
-        this.batchTimer = null;
-        this.flush();
-      }, this.config.batchTimeout);
-    }
-    clearBatchTimer() {
-      if (this.batchTimer) {
-        clearTimeout(this.batchTimer);
-        this.batchTimer = null;
+      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");
+        }
       }
-    }
-    async sendBatch(events) {
-      if (events.length === 0) return;
-      try {
-        const results = await Promise.allSettled(
-          events.map(async (event) => {
-            const response = await fetch(this.endpoint, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                ...event.headers || {}
-              },
-              body: JSON.stringify({
-                ...event.payload,
-                _queue_id: event.id,
-                _queue_timestamp: event.timestamp
-              })
-            });
-            if (!response.ok) {
-              throw new Error(`HTTP ${response.status}`);
-            }
-          })
-        );
-        const failedEvents = events.filter((_, index) => results[index]?.status === "rejected");
-        if (failedEvents.length > 0) {
-          for (const event of failedEvents) {
-            if (event.retries < this.config.maxRetries) {
-              event.retries++;
-              this.queue.push(event);
-            }
-          }
-          const delay = this.config.retryDelayMs * Math.pow(2, failedEvents[0].retries - 1);
-          setTimeout(() => this.flush(), delay);
+      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;
         }
-        return;
-      } catch (error) {
-        for (const event of events) {
-          if (event.retries < this.config.maxRetries) {
-            event.retries++;
-            this.queue.push(event);
-          }
+        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);
         }
-        if (this.queue.length > 0) {
-          const delay = this.config.retryDelayMs * Math.pow(2, events[0].retries - 1);
-          setTimeout(() => this.flush(), delay);
+        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");
         }
       }
-    }
-    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);
-          }
+      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);
         }
-      } catch {
-      }
-    }
-    saveToStorage() {
-      try {
-        if (this.queue.length > 0) {
-          localStorage.setItem(this.config.storageKey, JSON.stringify(this.queue));
+        const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+        if (avgInterval < 1e3) {
+          signals.push("focus_blur_rapid");
         } else {
-          this.clearStorage();
+          signals.push("focus_blur_normal");
         }
-      } catch {
       }
+      return signals;
     }
-    clearStorage() {
-      try {
-        localStorage.removeItem(this.config.storageKey);
-      } catch {
-      }
+    /**
+     * Add context signals (set by tracker from external data)
+     */
+    addContextSignal(_signal) {
     }
-    generateId() {
-      return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    /**
+     * Get current result (null if not yet classified)
+     */
+    getResult() {
+      return this.result;
+    }
+    /**
+     * Check if classification has been performed
+     */
+    hasClassified() {
+      return this.classified;
     }
   };
 
-  // src/infrastructure/ping.ts
-  var PingService = class {
-    constructor(sessionId2, visitorId2, version, config2 = {}) {
-      this.intervalId = null;
-      this.isVisible = true;
-      this.isFocused = 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.handleFocusChange = () => {
-        this.isFocused = typeof document.hasFocus === "function" ? document.hasFocus() : true;
-        if (this.intervalId && this.isVisible && this.isFocused) {
-          this.ping();
-        }
-      };
-      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.isVisible = document.visibilityState === "visible";
-      this.isFocused = typeof document.hasFocus === "function" ? document.hasFocus() : true;
-      this.config = {
-        interval: DEFAULT_CONFIG.pingInterval,
-        endpoint: "",
-        ...config2
-      };
-      document.addEventListener("visibilitychange", this.handleVisibilityChange);
-      window.addEventListener("focus", this.handleFocusChange);
-      window.addEventListener("blur", this.handleFocusChange);
-      window.addEventListener("scroll", this.handleScroll, { passive: true });
+  // src/detection/focus-blur.ts
+  var FocusBlurAnalyzer = class {
+    constructor() {
+      this.sequence = [];
+      this.firstInteractionTime = null;
+      this.analyzed = false;
+      this.result = null;
+      this.pageLoadTime = performance.now();
     }
     /**
-     * Start the ping service
+     * Initialize event tracking
+     * Must be called after DOM is ready
      */
-    start() {
-      if (this.intervalId) return;
-      this.intervalId = setInterval(() => {
-        if (this.isVisible && this.isFocused) {
-          this.ping();
+    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();
         }
-      }, this.config.interval);
-      if (this.isVisible && this.isFocused) {
-        this.ping();
-      }
+      };
+      document.addEventListener("click", recordFirstInteraction, { once: true, passive: true });
+      document.addEventListener("keydown", recordFirstInteraction, { once: true, passive: true });
     }
     /**
-     * Stop the ping service
+     * Record a focus/blur event
      */
-    stop() {
-      if (this.intervalId) {
-        clearInterval(this.intervalId);
-        this.intervalId = null;
+    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);
       }
-      document.removeEventListener("visibilitychange", this.handleVisibilityChange);
-      window.removeEventListener("focus", this.handleFocusChange);
-      window.removeEventListener("blur", this.handleFocusChange);
-      window.removeEventListener("scroll", this.handleScroll);
     }
     /**
-     * Update scroll depth (called by external scroll tracker)
+     * Analyze the focus/blur sequence for paste patterns
      */
-    updateScrollDepth(depth) {
-      if (depth > this.currentScrollDepth) {
-        this.currentScrollDepth = depth;
+    analyze() {
+      if (this.analyzed && this.result) {
+        return this.result;
       }
-    }
-    /**
-     * 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 && this.isFocused,
-        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;
+      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.handleVisibility = () => {
-        this.isVisible = document.visibilityState === "visible";
-      };
-      this.config = {
-        chunks: DEFAULT_CHUNKS,
-        ...config2
-      };
-      this.startTime = Date.now();
+      this.analyzed = true;
+      return this.result;
     }
     /**
-     * Start tracking scroll depth
+     * Get current result (analyze if not done)
      */
-    start() {
-      window.addEventListener("scroll", this.handleScroll, { passive: true });
-      document.addEventListener("visibilitychange", this.handleVisibility);
-      this.checkScrollDepth();
+    getResult() {
+      return this.analyze();
     }
     /**
-     * Stop tracking
+     * Check if analysis has been performed
      */
-    stop() {
-      window.removeEventListener("scroll", this.handleScroll);
-      document.removeEventListener("visibilitychange", this.handleVisibility);
+    hasAnalyzed() {
+      return this.analyzed;
     }
     /**
-     * Get current max scroll depth
+     * Get the raw sequence for debugging
      */
-    getMaxDepth() {
-      return this.maxDepth;
+    getSequence() {
+      return [...this.sequence];
     }
     /**
-     * Get reported chunks
+     * Reset the analyzer
      */
-    getReportedChunks() {
-      return Array.from(this.reportedChunks).sort((a, b) => a - b);
+    reset() {
+      this.sequence = [];
+      this.pageLoadTime = performance.now();
+      this.firstInteractionTime = null;
+      this.analyzed = false;
+      this.result = null;
     }
-    /**
-     * Get final scroll event (for unload)
-     */
-    getFinalEvent() {
-      const docHeight = document.documentElement.scrollHeight;
-      const viewportHeight = window.innerHeight;
+  };
+
+  // src/detection/navigation-timing.ts
+  function detectNavigationType() {
+    try {
+      const entries = performance.getEntriesByType("navigation");
+      if (!entries || entries.length === 0) {
+        return { nav_type: "unknown", confidence: 0, signals: ["no_timing_data"] };
+      }
+      const nav = entries[0];
+      const signals = [];
+      let pasteScore = 0;
+      const fetchStartDelta = nav.fetchStart - nav.startTime;
+      if (fetchStartDelta < 5) {
+        pasteScore += 0.25;
+        signals.push("instant_fetch_start");
+      } else if (fetchStartDelta < 20) {
+        pasteScore += 0.15;
+        signals.push("fast_fetch_start");
+      }
+      const dnsTime = nav.domainLookupEnd - nav.domainLookupStart;
+      if (dnsTime === 0) {
+        pasteScore += 0.15;
+        signals.push("no_dns_lookup");
+      }
+      const connectTime = nav.connectEnd - nav.connectStart;
+      if (connectTime === 0) {
+        pasteScore += 0.15;
+        signals.push("no_tcp_connect");
+      }
+      if (nav.redirectCount === 0) {
+        pasteScore += 0.1;
+        signals.push("no_redirects");
+      }
+      const timingVariance = calculateTimingVariance(nav);
+      if (timingVariance < 10) {
+        pasteScore += 0.15;
+        signals.push("uniform_timing");
+      }
+      if (!document.referrer || document.referrer === "") {
+        pasteScore += 0.1;
+        signals.push("no_referrer");
+      }
+      const confidence = Math.min(pasteScore, 1);
+      const nav_type = pasteScore >= 0.5 ? "likely_paste" : "likely_click";
       return {
-        depth: this.maxDepth,
-        chunk: this.getChunkForDepth(this.maxDepth),
-        time_to_reach_ms: Date.now() - this.startTime,
-        total_height: docHeight,
-        viewport_height: viewportHeight
+        nav_type,
+        confidence: Math.round(confidence * 1e3) / 1e3,
+        signals
       };
+    } catch {
+      return { nav_type: "unknown", confidence: 0, signals: ["detection_error"] };
     }
-    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);
+  }
+  function calculateTimingVariance(nav) {
+    const timings = [
+      nav.fetchStart - nav.startTime,
+      nav.domainLookupEnd - nav.domainLookupStart,
+      nav.connectEnd - nav.connectStart,
+      nav.responseStart - nav.requestStart
+    ].filter((t) => t >= 0);
+    if (timings.length === 0) return 100;
+    const mean = timings.reduce((a, b) => a + b, 0) / timings.length;
+    const variance = timings.reduce((sum, t) => sum + Math.pow(t - mean, 2), 0) / timings.length;
+    return Math.sqrt(variance);
+  }
+
+  // src/detection/referrer.ts
+  function detectAIFromReferrer(referrer) {
+    if (!referrer) {
+      return null;
     }
-    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);
+    try {
+      const url = new URL(referrer);
+      const hostname = url.hostname.toLowerCase();
+      for (const [pattern, platform] of Object.entries(AI_PLATFORMS)) {
+        if (hostname.includes(pattern) || referrer.includes(pattern)) {
+          return {
+            isAI: true,
+            platform,
+            confidence: 0.95,
+            // High confidence when referrer matches
+            method: "referrer"
+          };
         }
       }
+      return null;
+    } catch {
+      for (const [pattern, platform] of Object.entries(AI_PLATFORMS)) {
+        if (referrer.toLowerCase().includes(pattern.toLowerCase())) {
+          return {
+            isAI: true,
+            platform,
+            confidence: 0.85,
+            method: "referrer"
+          };
+        }
+      }
+      return null;
     }
-    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;
+  }
+  function detectAIFromUTM(url) {
+    try {
+      const params = new URL(url).searchParams;
+      const utmSource = params.get("utm_source")?.toLowerCase();
+      if (utmSource) {
+        for (const [pattern, platform] of Object.entries(AI_PLATFORMS)) {
+          if (utmSource.includes(pattern.split(".")[0])) {
+            return {
+              isAI: true,
+              platform,
+              confidence: 0.99,
+              // Very high confidence from explicit UTM
+              method: "referrer"
+            };
+          }
+        }
+        if (utmSource.includes("ai") || utmSource.includes("llm") || utmSource.includes("chatbot")) {
+          return {
+            isAI: true,
+            platform: utmSource,
+            confidence: 0.9,
+            method: "referrer"
+          };
+        }
       }
-      return 0;
+      return null;
+    } catch {
+      return null;
     }
-  };
+  }
 
-  // src/behavioral/time-tracker.ts
-  var DEFAULT_CONFIG2 = {
-    idleThresholdMs: 3e4,
-    // 30 seconds
-    updateIntervalMs: 5e3
-    // 5 seconds
+  // src/infrastructure/event-queue.ts
+  var DEFAULT_QUEUE_CONFIG = {
+    batchSize: DEFAULT_CONFIG3.batchSize,
+    batchTimeout: DEFAULT_CONFIG3.batchTimeout,
+    maxRetries: 3,
+    retryDelayMs: 1e3,
+    storageKey: "_loamly_queue"
   };
-  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;
+  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();
     }
     /**
-     * Start tracking time
+     * Add event to queue
      */
-    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);
+    push(type, payload, headers) {
+      const event = {
+        id: this.generateId(),
+        type,
+        payload,
+        headers,
+        timestamp: Date.now(),
+        retries: 0
+      };
+      this.queue.push(event);
+      this.saveToStorage();
+      this.scheduleBatch();
     }
     /**
-     * Stop tracking
+     * Force flush all events immediately
      */
-    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;
+    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();
       }
     }
     /**
-     * Get current time metrics
+     * Flush using sendBeacon (for unload events)
      */
-    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
-      };
+    flushBeacon() {
+      if (this.queue.length === 0) return true;
+      const baseUrl = this.config.apiKey ? `${this.endpoint}?api_key=${encodeURIComponent(this.config.apiKey)}` : this.endpoint;
+      let allSent = true;
+      for (const event of this.queue) {
+        const payload = {
+          ...event.payload,
+          _queue_id: event.id,
+          _queue_timestamp: event.timestamp
+        };
+        const success = navigator.sendBeacon?.(baseUrl, JSON.stringify(payload)) ?? false;
+        if (!success) {
+          allSent = false;
+          break;
+        }
+      }
+      if (allSent) {
+        this.queue = [];
+        this.clearStorage();
+      }
+      return allSent;
     }
     /**
-     * Get final metrics (for unload)
+     * Get current queue length
      */
-    getFinalMetrics() {
-      this.updateTimes();
-      return this.getMetrics();
+    get length() {
+      return this.queue.length;
     }
-    checkIdle() {
-      const now = Date.now();
-      const timeSinceActivity = now - this.lastActivityTime;
-      if (!this.isIdle && timeSinceActivity >= this.config.idleThresholdMs) {
-        this.isIdle = true;
+    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);
     }
-    updateTimes() {
-      const now = Date.now();
-      const elapsed = now - this.lastUpdateTime;
-      if (this.isVisible) {
-        if (this.isIdle) {
-          this.idleTime += elapsed;
-        } else {
-          this.activeTime += elapsed;
+    clearBatchTimer() {
+      if (this.batchTimer) {
+        clearTimeout(this.batchTimer);
+        this.batchTimer = null;
+      }
+    }
+    async sendBatch(events) {
+      if (events.length === 0) return;
+      try {
+        const results = await Promise.allSettled(
+          events.map(async (event) => {
+            const response = await fetch(this.endpoint, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                ...event.headers || {}
+              },
+              body: JSON.stringify({
+                ...event.payload,
+                _queue_id: event.id,
+                _queue_timestamp: event.timestamp
+              })
+            });
+            if (!response.ok) {
+              throw new Error(`HTTP ${response.status}`);
+            }
+          })
+        );
+        const failedEvents = events.filter((_, index) => results[index]?.status === "rejected");
+        if (failedEvents.length > 0) {
+          for (const event of failedEvents) {
+            if (event.retries < this.config.maxRetries) {
+              event.retries++;
+              this.queue.push(event);
+            }
+          }
+          const delay = this.config.retryDelayMs * Math.pow(2, failedEvents[0].retries - 1);
+          setTimeout(() => this.flush(), delay);
+        }
+        return;
+      } 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);
         }
       }
-      this.lastUpdateTime = now;
     }
-    update() {
-      if (!this.isVisible) return;
-      this.updateTimes();
-      this.config.onUpdate?.(this.getMetrics());
+    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 {
+      }
     }
-  };
-
-  // 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)
-          });
+    saveToStorage() {
+      try {
+        if (this.queue.length > 0) {
+          localStorage.setItem(this.config.storageKey, JSON.stringify(this.queue));
+        } else {
+          this.clearStorage();
         }
-        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()
-          });
+      } 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.isFocused = 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.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,
-          submit_source: "submit"
-        });
+      this.handleVisibilityChange = () => {
+        this.isVisible = document.visibilityState === "visible";
       };
-      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,
-              submit_source: "click"
-            });
-          }
+      this.handleFocusChange = () => {
+        this.isFocused = typeof document.hasFocus === "function" ? document.hasFocus() : true;
+        if (this.intervalId && this.isVisible && this.isFocused) {
+          this.ping();
         }
-        if (target.closest('[data-qa="submit-button"]')) {
-          this.emitEvent({
-            event_type: "form_submit",
-            form_id: "typeform_embed",
-            form_type: "typeform",
-            is_conversion: true,
-            submit_source: "click"
-          });
+      };
+      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.isVisible = document.visibilityState === "visible";
+      this.isFocused = typeof document.hasFocus === "function" ? document.hasFocus() : true;
       this.config = {
-        ...DEFAULT_CONFIG3,
-        ...config2,
-        sensitiveFields: [
-          ...DEFAULT_CONFIG3.sensitiveFields,
-          ...config2.sensitiveFields || []
-        ]
+        interval: DEFAULT_CONFIG3.pingInterval,
+        endpoint: "",
+        ...config2
       };
+      document.addEventListener("visibilitychange", this.handleVisibilityChange);
+      window.addEventListener("focus", this.handleFocusChange);
+      window.addEventListener("blur", this.handleFocusChange);
+      window.addEventListener("scroll", this.handleScroll, { passive: true });
     }
     /**
-     * Start tracking forms
+     * Start the ping service
      */
     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();
+      if (this.intervalId) return;
+      this.intervalId = setInterval(() => {
+        if (this.isVisible && this.isFocused) {
+          this.ping();
+        }
+      }, this.config.interval);
+      if (this.isVisible && this.isFocused) {
+        this.ping();
+      }
     }
     /**
-     * Stop tracking
+     * Stop the ping service
      */
     stop() {
-      document.removeEventListener("focusin", this.handleFocusIn);
-      document.removeEventListener("submit", this.handleSubmit);
-      document.removeEventListener("click", this.handleClick);
-      this.mutationObserver?.disconnect();
+      if (this.intervalId) {
+        clearInterval(this.intervalId);
+        this.intervalId = null;
+      }
+      document.removeEventListener("visibilitychange", this.handleVisibilityChange);
+      window.removeEventListener("focus", this.handleFocusChange);
+      window.removeEventListener("blur", this.handleFocusChange);
+      window.removeEventListener("scroll", this.handleScroll);
     }
     /**
-     * Get forms that had interaction
+     * Update scroll depth (called by external scroll tracker)
      */
-    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,
-            submit_source: "thank_you"
-          });
-          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";
+    updateScrollDepth(depth) {
+      if (depth > this.currentScrollDepth) {
+        this.currentScrollDepth = depth;
       }
-      return "unknown";
     }
-    emitEvent(event) {
-      this.config.onFormEvent?.(event);
+    /**
+     * 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 && this.isFocused,
+        tracker_version: this.version
+      };
     }
   };
 
@@ -1775,7 +1839,7 @@ var Loamly = (() => {
   }
 
   // src/core.ts
-  var config = { apiHost: DEFAULT_CONFIG.apiHost };
+  var config = { apiHost: DEFAULT_CONFIG3.apiHost };
   var initialized = false;
   var debugMode = false;
   var visitorId = null;
@@ -1833,7 +1897,7 @@ var Loamly = (() => {
     config = {
       ...config,
       ...userConfig,
-      apiHost: userConfig.apiHost || DEFAULT_CONFIG.apiHost
+      apiHost: userConfig.apiHost || DEFAULT_CONFIG3.apiHost
     };
     workspaceId = userConfig.workspaceId ?? null;
     debugMode = userConfig.debug ?? false;
@@ -1858,9 +1922,9 @@ var Loamly = (() => {
     visitorId = getVisitorId();
     log("Visitor ID:", visitorId);
     if (features.eventQueue) {
-      eventQueue = new EventQueue(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
-        batchSize: DEFAULT_CONFIG.batchSize,
-        batchTimeout: DEFAULT_CONFIG.batchTimeout,
+      eventQueue = new EventQueue(endpoint(DEFAULT_CONFIG3.endpoints.behavioral), {
+        batchSize: DEFAULT_CONFIG3.batchSize,
+        batchTimeout: DEFAULT_CONFIG3.batchTimeout,
         apiKey: config.apiKey
       });
     }
@@ -1899,8 +1963,8 @@ var Loamly = (() => {
       }
       if (features.ping && visitorId && sessionId) {
         pingService = new PingService(sessionId, visitorId, VERSION, {
-          interval: DEFAULT_CONFIG.pingInterval,
-          endpoint: endpoint(DEFAULT_CONFIG.endpoints.ping)
+          interval: DEFAULT_CONFIG3.pingInterval,
+          endpoint: endpoint(DEFAULT_CONFIG3.endpoints.ping)
         });
         pingService.start();
       }
@@ -1942,7 +2006,7 @@ var Loamly = (() => {
     try {
       const storedSession = sessionStorage.getItem("loamly_session");
       const storedStart = sessionStorage.getItem("loamly_start");
-      const sessionTimeout = config.sessionTimeout ?? DEFAULT_CONFIG.sessionTimeout;
+      const sessionTimeout = config.sessionTimeout ?? DEFAULT_CONFIG3.sessionTimeout;
       if (storedSession && storedStart) {
         const startTime = parseInt(storedStart, 10);
         const elapsed = now - startTime;
@@ -1956,7 +2020,7 @@ var Loamly = (() => {
     }
     if (config.apiKey && workspaceId && visitorId) {
       try {
-        const response = await safeFetch(endpoint(DEFAULT_CONFIG.endpoints.session), {
+        const response = await safeFetch(endpoint(DEFAULT_CONFIG3.endpoints.session), {
           method: "POST",
           headers: buildHeaders(),
           body: JSON.stringify({
@@ -2005,7 +2069,7 @@ var Loamly = (() => {
         updateIntervalMs: 1e4,
         // Report every 10 seconds
         onUpdate: (event) => {
-          if (event.active_time_ms >= DEFAULT_CONFIG.timeSpentThresholdMs) {
+          if (event.active_time_ms >= DEFAULT_CONFIG3.timeSpentThresholdMs) {
             queueEvent("time_spent", {
               visible_time_ms: event.total_time_ms,
               page_start_time: pageStartTime || Date.now()
@@ -2031,7 +2095,10 @@ var Loamly = (() => {
             form_event_type: event.event_type,
             submit_source: submitSource,
             is_inferred: isSuccessEvent,
-            time_to_submit_seconds: event.time_to_submit_ms ? Math.round(event.time_to_submit_ms / 1e3) : null
+            time_to_submit_seconds: event.time_to_submit_ms ? Math.round(event.time_to_submit_ms / 1e3) : null,
+            // LOA-482: Include captured form field values
+            fields: event.fields || null,
+            email_submitted: event.email_submitted || null
           });
         }
       });
@@ -2118,7 +2185,7 @@ var Loamly = (() => {
       if (!workspaceId || !config.apiKey || !sessionId) return;
       const scrollEvent = scrollTracker?.getFinalEvent();
       if (scrollEvent) {
-        sendBeacon(buildBeaconUrl(endpoint(DEFAULT_CONFIG.endpoints.behavioral)), {
+        sendBeacon(buildBeaconUrl(endpoint(DEFAULT_CONFIG3.endpoints.behavioral)), {
           workspace_id: workspaceId,
           visitor_id: visitorId,
           session_id: sessionId,
@@ -2137,7 +2204,7 @@ var Loamly = (() => {
       }
       const timeEvent = timeTracker?.getFinalMetrics();
       if (timeEvent) {
-        sendBeacon(buildBeaconUrl(endpoint(DEFAULT_CONFIG.endpoints.behavioral)), {
+        sendBeacon(buildBeaconUrl(endpoint(DEFAULT_CONFIG3.endpoints.behavioral)), {
           workspace_id: workspaceId,
           visitor_id: visitorId,
           session_id: sessionId,
@@ -2219,7 +2286,7 @@ var Loamly = (() => {
       payload.workspace_id = workspaceId;
     }
     log("Pageview:", payload);
-    safeFetch(endpoint(DEFAULT_CONFIG.endpoints.visit), {
+    safeFetch(endpoint(DEFAULT_CONFIG3.endpoints.visit), {
       method: "POST",
       headers: buildHeaders(idempotencyKey),
       body: JSON.stringify(payload)
@@ -2440,7 +2507,7 @@ var Loamly = (() => {
           event_queue: !!eventQueue
         }
       };
-      safeFetch(endpoint(DEFAULT_CONFIG.endpoints.health), {
+      safeFetch(endpoint(DEFAULT_CONFIG3.endpoints.health), {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(healthData)
@@ -2484,14 +2551,28 @@ var Loamly = (() => {
     debugMode = enabled;
     log("Debug mode:", enabled ? "enabled" : "disabled");
   }
+  function trackBehavioral(eventType, eventData) {
+    if (!initialized) {
+      log("Not initialized, trackBehavioral skipped:", eventType);
+      return;
+    }
+    queueEvent(eventType, eventData);
+  }
+  function getCurrentWorkspaceId() {
+    return workspaceId;
+  }
   var loamly = {
     init,
     pageview,
     track,
+    trackBehavioral,
+    // NEW: For secondary modules/plugins
     conversion,
     identify,
     getSessionId: getCurrentSessionId,
     getVisitorId: getCurrentVisitorId,
+    getWorkspaceId: getCurrentWorkspaceId,
+    // NEW: For debugging/introspection
     getAIDetection: getAIDetectionResult,
     getNavigationTiming: getNavigationTimingResult,
     getBehavioralML: getBehavioralMLResult,
@@ -2521,7 +2602,7 @@ var Loamly = (() => {
   }
   async function resolveWorkspaceConfig(domain) {
     try {
-      const response = await fetch(`${DEFAULT_CONFIG.apiHost}${DEFAULT_CONFIG.endpoints.resolve}?d=${encodeURIComponent(domain)}`);
+      const response = await fetch(`${DEFAULT_CONFIG3.apiHost}${DEFAULT_CONFIG3.endpoints.resolve}?d=${encodeURIComponent(domain)}`);
       if (!response.ok) {
         console.warn("[Loamly] Failed to resolve workspace for domain:", domain);
         return null;
@@ -2531,7 +2612,7 @@ var Loamly = (() => {
         return {
           apiKey: data.public_key,
           workspaceId: data.workspace_id,
-          apiHost: DEFAULT_CONFIG.apiHost
+          apiHost: DEFAULT_CONFIG3.apiHost
         };
       }
       return null;