@loamly/tracker 2.1.1 → 2.4.0

package/dist/index.cjs

@@ -33,645 +33,596 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// 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
 };
-var AI_BOT_PATTERNS = [
-  "GPTBot",
-  "ChatGPT-User",
-  "ClaudeBot",
-  "Claude-Web",
-  "PerplexityBot",
-  "Amazonbot",
-  "Google-Extended",
-  "CCBot",
-  "anthropic-ai",
-  "cohere-ai"
-];
-
-// 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"
-        };
-      }
-    }
-    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();
+      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.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 (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.classList.contains("jotform-form") || element.closest(".jotform-form")) {
+      return "jotform";
     }
-    return signals;
+    if (element.classList.contains("gform_wrapper") || element.closest(".gform_wrapper")) {
+      return "gravity";
+    }
+    if (element.tagName === "FORM") {
+      return "native";
+    }
+    return "unknown";
+  }
+  emitEvent(event) {
+    this.config.onFormEvent?.(event);
+  }
+};
+
+// src/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.handleActivity = () => {
+      const now = Date.now();
+      if (this.isIdle) {
+        this.isIdle = false;
+      }
+      this.lastActivityTime = now;
     };
-    this.analyzed = true;
-    return this.result;
+    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"
+};
+var AI_BOT_PATTERNS = [
+  "GPTBot",
+  "ChatGPT-User",
+  "ClaudeBot",
+  "Claude-Web",
+  "PerplexityBot",
+  "Amazonbot",
+  "Google-Extended",
+  "CCBot",
+  "anthropic-ai",
+  "cohere-ai"
+];
+
 // src/detection/agentic-browser.ts
 var CometDetector = class {
   constructor() {
@@ -873,764 +824,877 @@ function createAgenticAnalyzer() {
   return analyzer;
 }
 
-// src/infrastructure/event-queue.ts
-var DEFAULT_QUEUE_CONFIG = {
-  batchSize: DEFAULT_CONFIG.batchSize,
-  batchTimeout: DEFAULT_CONFIG.batchTimeout,
-  maxRetries: 3,
-  retryDelayMs: 1e3,
-  storageKey: "_loamly_queue"
+// 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 EventQueue = class {
-  constructor(endpoint2, config2 = {}) {
-    this.queue = [];
-    this.batchTimer = null;
-    this.isFlushing = false;
-    this.endpoint = endpoint2;
-    this.config = { ...DEFAULT_QUEUE_CONFIG, ...config2 };
-    this.loadFromStorage();
+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();
   }
   /**
-   * Add event to queue
+   * Record form field interaction start
    */
-  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();
+  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 });
+    }
   }
   /**
-   * Force flush all events immediately
+   * Record form field interaction end
    */
-  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();
+  recordFormEnd(fieldId) {
+    const event = this.data.formEvents.find((e) => e.fieldId === fieldId && e.endTime === 0);
+    if (event) {
+      event.endTime = Date.now();
     }
+    this.checkAndClassify();
   }
   /**
-   * Flush using sendBeacon (for unload events)
+   * Record focus/blur event
    */
-  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();
+  recordFocusBlur(type) {
+    this.data.focusBlurEvents.push({ type, time: Date.now() });
+    if (this.data.focusBlurEvents.length > 20) {
+      this.data.focusBlurEvents = this.data.focusBlurEvents.slice(-20);
     }
-    return allSent;
   }
   /**
-   * Get current queue length
+   * Check if we have enough data and classify
    */
-  get length() {
-    return this.queue.length;
+  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();
   }
-  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);
+  /**
+   * Force classification (for beforeunload)
+   */
+  forceClassify() {
+    if (this.classified) return this.result;
+    return this.classify();
   }
-  clearBatchTimer() {
-    if (this.batchTimer) {
-      clearTimeout(this.batchTimer);
-      this.batchTimer = null;
+  /**
+   * Perform classification
+   */
+  classify() {
+    const sessionDuration = Date.now() - this.data.startTime;
+    const signals = this.extractSignals();
+    let humanLogProb = Math.log(PRIORS.human);
+    let aiLogProb = Math.log(PRIORS.ai_influenced);
+    for (const signal of signals) {
+      const humanWeight = NAIVE_BAYES_WEIGHTS.human[signal] ?? DEFAULT_WEIGHT;
+      const aiWeight = NAIVE_BAYES_WEIGHTS.ai_influenced[signal] ?? DEFAULT_WEIGHT;
+      humanLogProb += Math.log(humanWeight);
+      aiLogProb += Math.log(aiWeight);
+    }
+    const maxLog = Math.max(humanLogProb, aiLogProb);
+    const humanExp = Math.exp(humanLogProb - maxLog);
+    const aiExp = Math.exp(aiLogProb - maxLog);
+    const total = humanExp + aiExp;
+    const humanProbability = humanExp / total;
+    const aiProbability = aiExp / total;
+    let classification;
+    let confidence;
+    if (humanProbability > 0.6) {
+      classification = "human";
+      confidence = humanProbability;
+    } else if (aiProbability > 0.6) {
+      classification = "ai_influenced";
+      confidence = aiProbability;
+    } else {
+      classification = "uncertain";
+      confidence = Math.max(humanProbability, aiProbability);
+    }
+    this.result = {
+      classification,
+      humanProbability,
+      aiProbability,
+      confidence,
+      signals,
+      timestamp: Date.now(),
+      sessionDurationMs: sessionDuration
+    };
+    this.classified = true;
+    if (this.onClassify) {
+      this.onClassify(this.result);
     }
+    return this.result;
   }
-  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);
+  /**
+   * Extract behavioral signals from collected data
+   */
+  extractSignals() {
+    const signals = [];
+    if (this.data.firstClickTime !== null) {
+      const timeToClick = this.data.firstClickTime - this.data.startTime;
+      if (timeToClick < 500) {
+        signals.push("time_to_first_click_immediate");
+      } else if (timeToClick < 2e3) {
+        signals.push("time_to_first_click_fast");
+      } else if (timeToClick < 1e4) {
+        signals.push("time_to_first_click_normal");
+      } else {
+        signals.push("time_to_first_click_delayed");
       }
-      return;
-    } catch (error) {
-      for (const event of events) {
-        if (event.retries < this.config.maxRetries) {
-          event.retries++;
-          this.queue.push(event);
-        }
+    }
+    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);
       }
-      if (this.queue.length > 0) {
-        const delay = this.config.retryDelayMs * Math.pow(2, events[0].retries - 1);
-        setTimeout(() => this.flush(), delay);
+      const mean = scrollDeltas.reduce((a, b) => a + b, 0) / scrollDeltas.length;
+      const variance = scrollDeltas.reduce((sum, d) => sum + Math.pow(d - mean, 2), 0) / scrollDeltas.length;
+      const stdDev = Math.sqrt(variance);
+      const cv = mean > 0 ? stdDev / mean : 0;
+      if (cv < 0.2) {
+        signals.push("scroll_speed_uniform");
+      } else if (cv < 0.6) {
+        signals.push("scroll_speed_variable");
+      } else {
+        signals.push("scroll_speed_erratic");
+      }
+    }
+    if (this.data.mouseEvents.length === 0) {
+      signals.push("mouse_movement_none");
+    } else if (this.data.mouseEvents.length >= 10) {
+      const n = Math.min(this.data.mouseEvents.length, 20);
+      const recentMouse = this.data.mouseEvents.slice(-n);
+      let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
+      for (const event of recentMouse) {
+        sumX += event.x;
+        sumY += event.y;
+        sumXY += event.x * event.y;
+        sumX2 += event.x * event.x;
+      }
+      const denominator = n * sumX2 - sumX * sumX;
+      const slope = denominator !== 0 ? (n * sumXY - sumX * sumY) / denominator : 0;
+      const intercept = (sumY - slope * sumX) / n;
+      let ssRes = 0, ssTot = 0;
+      const yMean = sumY / n;
+      for (const event of recentMouse) {
+        const yPred = slope * event.x + intercept;
+        ssRes += Math.pow(event.y - yPred, 2);
+        ssTot += Math.pow(event.y - yMean, 2);
+      }
+      const r2 = ssTot !== 0 ? 1 - ssRes / ssTot : 0;
+      if (r2 > 0.95) {
+        signals.push("mouse_movement_linear");
+      } else {
+        signals.push("mouse_movement_curved");
+      }
+    }
+    const completedForms = this.data.formEvents.filter((e) => e.endTime > 0);
+    if (completedForms.length > 0) {
+      const avgFillTime = completedForms.reduce((sum, e) => sum + (e.endTime - e.startTime), 0) / completedForms.length;
+      if (avgFillTime < 100) {
+        signals.push("form_fill_instant");
+      } else if (avgFillTime < 500) {
+        signals.push("form_fill_fast");
+      } else {
+        signals.push("form_fill_normal");
       }
     }
-  }
-  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
+    };
   }
 };
 
@@ -1806,7 +1870,7 @@ function sendBeacon(url, data) {
 }
 
 // src/core.ts
-var config = { apiHost: DEFAULT_CONFIG.apiHost };
+var config = { apiHost: DEFAULT_CONFIG3.apiHost };
 var initialized = false;
 var debugMode = false;
 var visitorId = null;
@@ -1864,7 +1928,7 @@ function init(userConfig = {}) {
   config = {
     ...config,
     ...userConfig,
-    apiHost: userConfig.apiHost || DEFAULT_CONFIG.apiHost
+    apiHost: userConfig.apiHost || DEFAULT_CONFIG3.apiHost
   };
   workspaceId = userConfig.workspaceId ?? null;
   debugMode = userConfig.debug ?? false;
@@ -1889,9 +1953,9 @@ function init(userConfig = {}) {
   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
     });
   }
@@ -1930,8 +1994,8 @@ function init(userConfig = {}) {
     }
     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();
     }
@@ -1973,7 +2037,7 @@ async function initializeSession() {
   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;
@@ -1987,7 +2051,7 @@ async function initializeSession() {
   }
   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({
@@ -2036,7 +2100,7 @@ function setupAdvancedBehavioralTracking(features) {
       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()
@@ -2062,7 +2126,10 @@ function setupAdvancedBehavioralTracking(features) {
           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
         });
       }
     });
@@ -2149,7 +2216,7 @@ function setupUnloadHandlers() {
     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,
@@ -2168,7 +2235,7 @@ function setupUnloadHandlers() {
     }
     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,
@@ -2250,7 +2317,7 @@ function pageview(customUrl) {
     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)
@@ -2471,7 +2538,7 @@ function reportHealth(status, errorMessage) {
         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)
@@ -2515,14 +2582,28 @@ function setDebug(enabled) {
   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,