@loamly/tracker 2.1.0 → 2.4.0

package/dist/loamly.iife.global.js

@@ -25,633 +25,584 @@ var Loamly = (() => {
     loamly: () => loamly
   });
 
-  // src/config.ts
-  var VERSION = "2.1.0";
+  // 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()
+      };
+      this.config = {
+        ...DEFAULT_CONFIG,
+        ...config2,
+        sensitiveFields: [
+          ...DEFAULT_CONFIG.sensitiveFields,
+          ...config2.sensitiveFields || []
+        ]
       };
     }
     /**
-     * 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
+     * Start tracking forms
      */
-    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();
+    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();
     }
     /**
-     * Record mouse movement
+     * Stop tracking
      */
-    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();
+    stop() {
+      document.removeEventListener("focusin", this.handleFocusIn);
+      document.removeEventListener("submit", this.handleSubmit);
+      document.removeEventListener("click", this.handleClick);
+      this.mutationObserver?.disconnect();
     }
     /**
-     * Record form field interaction start
+     * Get forms that had interaction
      */
-    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 });
-      }
+    getInteractedForms() {
+      return Array.from(this.interactedForms);
     }
     /**
-     * Record form field interaction end
+     * 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
      */
-    recordFormEnd(fieldId) {
-      const event = this.data.formEvents.find((e) => e.fieldId === fieldId && e.endTime === 0);
-      if (event) {
-        event.endTime = Date.now();
+    captureFormFields(form) {
+      const fields = [];
+      let emailSubmitted;
+      if (!this.config.captureFieldValues) {
+        return { fields, emailSubmitted };
       }
-      this.checkAndClassify();
-    }
-    /**
-     * Record focus/blur event
-     */
-    recordFocusBlur(type) {
-      this.data.focusBlurEvents.push({ type, time: Date.now() });
-      if (this.data.focusBlurEvents.length > 20) {
-        this.data.focusBlurEvents = this.data.focusBlurEvents.slice(-20);
+      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 { fields, emailSubmitted };
     }
     /**
-     * Check if we have enough data and classify
+     * Check if a field contains an email
      */
-    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();
+    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;
     }
-    /**
-     * Force classification (for beforeunload)
-     */
-    forceClassify() {
-      if (this.classified) return this.result;
-      return this.classify();
+    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
+      });
     }
-    /**
-     * 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;
+    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");
+      });
     }
-    /**
-     * Extract behavioral signals from collected data
-     */
-    extractSignals() {
-      const signals = [];
-      if (this.data.firstClickTime !== null) {
-        const timeToClick = this.data.firstClickTime - this.data.startTime;
-        if (timeToClick < 500) {
-          signals.push("time_to_first_click_immediate");
-        } else if (timeToClick < 2e3) {
-          signals.push("time_to_first_click_fast");
-        } else if (timeToClick < 1e4) {
-          signals.push("time_to_first_click_normal");
-        } else {
-          signals.push("time_to_first_click_delayed");
-        }
-      }
-      if (this.data.scrollEvents.length === 0) {
-        signals.push("scroll_speed_none");
-      } else if (this.data.scrollEvents.length >= 3) {
-        const scrollDeltas = [];
-        for (let i = 1; i < this.data.scrollEvents.length; i++) {
-          const delta = this.data.scrollEvents[i].time - this.data.scrollEvents[i - 1].time;
-          scrollDeltas.push(delta);
-        }
-        const mean = scrollDeltas.reduce((a, b) => a + b, 0) / scrollDeltas.length;
-        const variance = scrollDeltas.reduce((sum, d) => sum + Math.pow(d - mean, 2), 0) / scrollDeltas.length;
-        const stdDev = Math.sqrt(variance);
-        const cv = mean > 0 ? stdDev / mean : 0;
-        if (cv < 0.2) {
-          signals.push("scroll_speed_uniform");
-        } else if (cv < 0.6) {
-          signals.push("scroll_speed_variable");
-        } else {
-          signals.push("scroll_speed_erratic");
-        }
-      }
-      if (this.data.mouseEvents.length === 0) {
-        signals.push("mouse_movement_none");
-      } else if (this.data.mouseEvents.length >= 10) {
-        const n = Math.min(this.data.mouseEvents.length, 20);
-        const recentMouse = this.data.mouseEvents.slice(-n);
-        let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
-        for (const event of recentMouse) {
-          sumX += event.x;
-          sumY += event.y;
-          sumXY += event.x * event.y;
-          sumX2 += event.x * event.x;
-        }
-        const denominator = n * sumX2 - sumX * sumX;
-        const slope = denominator !== 0 ? (n * sumXY - sumX * sumY) / denominator : 0;
-        const intercept = (sumY - slope * sumX) / n;
-        let ssRes = 0, ssTot = 0;
-        const yMean = sumY / n;
-        for (const event of recentMouse) {
-          const yPred = slope * event.x + intercept;
-          ssRes += Math.pow(event.y - yPred, 2);
-          ssTot += Math.pow(event.y - yMean, 2);
-        }
-        const r2 = ssTot !== 0 ? 1 - ssRes / ssTot : 0;
-        if (r2 > 0.95) {
-          signals.push("mouse_movement_linear");
-        } else {
-          signals.push("mouse_movement_curved");
+    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 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");
+      }, { 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.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");
-        }
+    }
+    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";
       }
-      return signals;
+      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";
+      }
+      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;
+    checkScrollDepth() {
+      const scrollY = window.scrollY;
+      const viewportHeight = window.innerHeight;
+      const docHeight = document.documentElement.scrollHeight;
+      if (docHeight <= viewportHeight) {
+        this.updateDepth(100);
+        return;
       }
-      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 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);
+        }
       }
-      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;
+    }
+    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;
       }
-      if (this.firstInteractionTime !== null) {
-        const timeToInteraction = this.firstInteractionTime - this.pageLoadTime;
-        if (timeToInteraction > 3e3) {
-          signals.push("delayed_first_interaction");
-          confidence += 0.1;
+      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();
         }
-      }
-      confidence = Math.min(confidence, 0.65);
-      let navType;
-      if (confidence >= 0.35) {
-        navType = "likely_paste";
-      } else if (signals.length === 0) {
-        navType = "unknown";
-      } else {
-        navType = "likely_click";
-      }
-      this.result = {
-        nav_type: navType,
-        confidence,
-        signals,
-        sequence: this.sequence.slice(-10),
-        time_to_first_interaction_ms: this.firstInteractionTime ? Math.round(this.firstInteractionTime - this.pageLoadTime) : null
       };
-      this.analyzed = true;
-      return this.result;
+      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() {
@@ -825,743 +776,894 @@ var Loamly = (() => {
         signals.push(`teleporting_clicks:${mousePatterns.teleportingClicks}`);
         probability = Math.max(probability, 0.78);
       }
-      return {
-        cometDOMDetected: this.cometDetector.isDetected(),
-        cdpDetected: this.cdpDetector.isDetected(),
-        mousePatterns,
-        agenticProbability: probability,
-        signals
-      };
+      return {
+        cometDOMDetected: this.cometDetector.isDetected(),
+        cdpDetected: this.cdpDetector.isDetected(),
+        mousePatterns,
+        agenticProbability: probability,
+        signals
+      };
+    }
+    /**
+     * 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();
     }
     /**
-     * Cleanup resources
+     * Record a scroll event
      */
-    destroy() {
-      this.cometDetector.destroy();
-      this.mouseAnalyzer.destroy();
+    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();
     }
-  };
-
-  // 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();
+    /**
+     * 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) {
-      const event = {
-        id: this.generateId(),
-        type,
-        payload,
-        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 events = this.queue.map((e) => ({
-        type: e.type,
-        ...e.payload,
-        _queue_id: e.id,
-        _queue_timestamp: e.timestamp
-      }));
-      const success = navigator.sendBeacon?.(
-        this.endpoint,
-        JSON.stringify({ events, beacon: true })
-      ) ?? false;
-      if (success) {
-        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 success;
     }
     /**
-     * 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);
       }
-    }
-    async sendBatch(events) {
-      if (events.length === 0) return;
-      const payload = {
-        events: events.map((e) => ({
-          type: e.type,
-          ...e.payload,
-          _queue_id: e.id,
-          _queue_timestamp: e.timestamp
-        })),
-        batch: true
+      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
       };
-      try {
-        const response = await fetch(this.endpoint, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(payload)
-        });
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}`);
+      this.classified = true;
+      if (this.onClassify) {
+        this.onClassify(this.result);
+      }
+      return this.result;
+    }
+    /**
+     * Extract behavioral signals from collected data
+     */
+    extractSignals() {
+      const signals = [];
+      if (this.data.firstClickTime !== null) {
+        const timeToClick = this.data.firstClickTime - this.data.startTime;
+        if (timeToClick < 500) {
+          signals.push("time_to_first_click_immediate");
+        } else if (timeToClick < 2e3) {
+          signals.push("time_to_first_click_fast");
+        } else if (timeToClick < 1e4) {
+          signals.push("time_to_first_click_normal");
+        } else {
+          signals.push("time_to_first_click_delayed");
         }
-      } 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");
         }
       }
-    }
-    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.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;
         }
-      } catch {
-      }
-    }
-    saveToStorage() {
-      try {
-        if (this.queue.length > 0) {
-          localStorage.setItem(this.config.storageKey, JSON.stringify(this.queue));
+        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 {
-          this.clearStorage();
+          signals.push("mouse_movement_curved");
         }
-      } 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.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 {
-          }
+      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");
         }
-      };
-      this.handleVisibilityChange = () => {
-        this.isVisible = document.visibilityState === "visible";
-      };
-      this.handleScroll = () => {
-        const scrollPercent = Math.round(
-          (window.scrollY + window.innerHeight) / document.documentElement.scrollHeight * 100
-        );
-        if (scrollPercent > this.currentScrollDepth) {
-          this.currentScrollDepth = Math.min(scrollPercent, 100);
+      }
+      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);
         }
-      };
-      this.sessionId = sessionId2;
-      this.visitorId = visitorId2;
-      this.version = version;
-      this.pageLoadTime = Date.now();
-      this.config = {
-        interval: DEFAULT_CONFIG.pingInterval,
-        endpoint: "",
-        ...config2
-      };
-      document.addEventListener("visibilitychange", this.handleVisibilityChange);
-      window.addEventListener("scroll", this.handleScroll, { passive: true });
-    }
-    /**
-     * Start the ping service
-     */
-    start() {
-      if (this.intervalId) return;
-      this.intervalId = setInterval(() => {
-        if (this.isVisible) {
-          this.ping();
+        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");
         }
-      }, this.config.interval);
-      this.ping();
+      }
+      return signals;
     }
     /**
-     * Stop the ping service
+     * Add context signals (set by tracker from external data)
      */
-    stop() {
-      if (this.intervalId) {
-        clearInterval(this.intervalId);
-        this.intervalId = null;
-      }
-      document.removeEventListener("visibilitychange", this.handleVisibilityChange);
-      window.removeEventListener("scroll", this.handleScroll);
+    addContextSignal(_signal) {
     }
     /**
-     * Update scroll depth (called by external scroll tracker)
+     * Get current result (null if not yet classified)
      */
-    updateScrollDepth(depth) {
-      if (depth > this.currentScrollDepth) {
-        this.currentScrollDepth = depth;
-      }
+    getResult() {
+      return this.result;
     }
     /**
-     * Get current ping data
+     * Check if classification has been performed
      */
-    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,
-        tracker_version: this.version
-      };
+    hasClassified() {
+      return this.classified;
     }
   };
 
-  // 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;
+  // src/detection/focus-blur.ts
+  var FocusBlurAnalyzer = class {
+    constructor() {
+      this.sequence = [];
+      this.firstInteractionTime = null;
+      this.analyzed = false;
+      this.result = null;
+      this.pageLoadTime = performance.now();
+    }
+    /**
+     * Initialize event tracking
+     * Must be called after DOM is ready
+     */
+    initTracking() {
+      document.addEventListener("focus", (e) => {
+        this.recordEvent("focus", e.target);
+      }, true);
+      document.addEventListener("blur", (e) => {
+        this.recordEvent("blur", e.target);
+      }, true);
+      window.addEventListener("focus", () => {
+        this.recordEvent("window_focus", null);
+      });
+      window.addEventListener("blur", () => {
+        this.recordEvent("window_blur", null);
+      });
+      const recordFirstInteraction = () => {
+        if (this.firstInteractionTime === null) {
+          this.firstInteractionTime = performance.now();
         }
       };
-      this.handleVisibility = () => {
-        this.isVisible = document.visibilityState === "visible";
-      };
-      this.config = {
-        chunks: DEFAULT_CHUNKS,
-        ...config2
+      document.addEventListener("click", recordFirstInteraction, { once: true, passive: true });
+      document.addEventListener("keydown", recordFirstInteraction, { once: true, passive: true });
+    }
+    /**
+     * Record a focus/blur event
+     */
+    recordEvent(type, target) {
+      const event = {
+        type,
+        target: target?.tagName || "WINDOW",
+        timestamp: performance.now()
       };
-      this.startTime = Date.now();
+      this.sequence.push(event);
+      if (this.sequence.length > 20) {
+        this.sequence = this.sequence.slice(-20);
+      }
     }
     /**
-     * Start tracking scroll depth
+     * Analyze the focus/blur sequence for paste patterns
      */
-    start() {
-      window.addEventListener("scroll", this.handleScroll, { passive: true });
-      document.addEventListener("visibilitychange", this.handleVisibility);
-      this.checkScrollDepth();
+    analyze() {
+      if (this.analyzed && this.result) {
+        return this.result;
+      }
+      const signals = [];
+      let confidence = 0;
+      const earlyEvents = this.sequence.filter((e) => e.timestamp < this.pageLoadTime + 500);
+      const hasEarlyWindowFocus = earlyEvents.some((e) => e.type === "window_focus");
+      if (hasEarlyWindowFocus) {
+        signals.push("early_window_focus");
+        confidence += 0.15;
+      }
+      const hasEarlyBodyFocus = earlyEvents.some(
+        (e) => e.type === "focus" && e.target === "BODY"
+      );
+      if (hasEarlyBodyFocus) {
+        signals.push("early_body_focus");
+        confidence += 0.15;
+      }
+      const hasLinkFocus = this.sequence.some(
+        (e) => e.type === "focus" && e.target === "A"
+      );
+      if (!hasLinkFocus) {
+        signals.push("no_link_focus");
+        confidence += 0.1;
+      }
+      const firstFocus = this.sequence.find((e) => e.type === "focus");
+      if (firstFocus && (firstFocus.target === "BODY" || firstFocus.target === "HTML")) {
+        signals.push("first_focus_body");
+        confidence += 0.1;
+      }
+      const windowEvents = this.sequence.filter(
+        (e) => e.type === "window_focus" || e.type === "window_blur"
+      );
+      if (windowEvents.length <= 2) {
+        signals.push("minimal_window_switches");
+        confidence += 0.05;
+      }
+      if (this.firstInteractionTime !== null) {
+        const timeToInteraction = this.firstInteractionTime - this.pageLoadTime;
+        if (timeToInteraction > 3e3) {
+          signals.push("delayed_first_interaction");
+          confidence += 0.1;
+        }
+      }
+      confidence = Math.min(confidence, 0.65);
+      let navType;
+      if (confidence >= 0.35) {
+        navType = "likely_paste";
+      } else if (signals.length === 0) {
+        navType = "unknown";
+      } else {
+        navType = "likely_click";
+      }
+      this.result = {
+        nav_type: navType,
+        confidence,
+        signals,
+        sequence: this.sequence.slice(-10),
+        time_to_first_interaction_ms: this.firstInteractionTime ? Math.round(this.firstInteractionTime - this.pageLoadTime) : null
+      };
+      this.analyzed = true;
+      return this.result;
     }
     /**
-     * Stop tracking
+     * Get current result (analyze if not done)
      */
-    stop() {
-      window.removeEventListener("scroll", this.handleScroll);
-      document.removeEventListener("visibilitychange", this.handleVisibility);
+    getResult() {
+      return this.analyze();
     }
     /**
-     * Get current max scroll depth
+     * Check if analysis has been performed
      */
-    getMaxDepth() {
-      return this.maxDepth;
+    hasAnalyzed() {
+      return this.analyzed;
     }
     /**
-     * Get reported chunks
+     * Get the raw sequence for debugging
      */
-    getReportedChunks() {
-      return Array.from(this.reportedChunks).sort((a, b) => a - b);
+    getSequence() {
+      return [...this.sequence];
     }
     /**
-     * Get final scroll event (for unload)
+     * Reset the analyzer
      */
-    getFinalEvent() {
-      const docHeight = document.documentElement.scrollHeight;
-      const viewportHeight = window.innerHeight;
+    reset() {
+      this.sequence = [];
+      this.pageLoadTime = performance.now();
+      this.firstInteractionTime = null;
+      this.analyzed = false;
+      this.result = null;
+    }
+  };
+
+  // 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;
+    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);
+        }
+      }
+    }
+    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 {
+      }
+    }
+    saveToStorage() {
+      try {
+        if (this.queue.length > 0) {
+          localStorage.setItem(this.config.storageKey, JSON.stringify(this.queue));
         } else {
-          this.activeTime += elapsed;
+          this.clearStorage();
         }
+      } catch {
       }
-      this.lastUpdateTime = now;
     }
-    update() {
-      if (!this.isVisible) return;
-      this.updateTimes();
-      this.config.onUpdate?.(this.getMetrics());
+    clearStorage() {
+      try {
+        localStorage.removeItem(this.config.storageKey);
+      } catch {
+      }
+    }
+    generateId() {
+      return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
     }
   };
 
-  // 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)
-          });
-        }
-        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()
-          });
+  // 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
-        });
+      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
-            });
-          }
+      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
-          });
+      };
+      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
-          });
-          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
+      };
     }
   };
 
@@ -1737,13 +1839,15 @@ 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;
   var sessionId = null;
+  var workspaceId = null;
   var navigationTiming = null;
   var aiDetection = null;
+  var pageStartTime = null;
   var behavioralClassifier = null;
   var behavioralMLResult = null;
   var focusBlurAnalyzer = null;
@@ -1763,6 +1867,28 @@ var Loamly = (() => {
   function endpoint(path) {
     return `${config.apiHost}${path}`;
   }
+  function buildHeaders(idempotencyKey) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (config.apiKey) {
+      headers["X-Loamly-Api-Key"] = config.apiKey;
+    }
+    if (idempotencyKey) {
+      headers["X-Idempotency-Key"] = idempotencyKey;
+    }
+    return headers;
+  }
+  function buildBeaconUrl(path) {
+    if (!config.apiKey) return path;
+    const url = new URL(path, config.apiHost);
+    url.searchParams.set("api_key", config.apiKey);
+    return url.toString();
+  }
+  function buildIdempotencyKey(prefix) {
+    const base = sessionId || visitorId || "unknown";
+    return `${prefix}:${base}:${Date.now()}`;
+  }
   function init(userConfig = {}) {
     if (initialized) {
       log("Already initialized");
@@ -1771,9 +1897,13 @@ 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;
+    if (config.apiKey && !workspaceId) {
+      log("Workspace ID missing. Behavioral events require workspaceId.");
+    }
     const features = {
       scroll: true,
       time: true,
@@ -1791,13 +1921,11 @@ var Loamly = (() => {
     log("Features:", features);
     visitorId = getVisitorId();
     log("Visitor ID:", visitorId);
-    const session = getSessionId();
-    sessionId = session.sessionId;
-    log("Session ID:", sessionId, session.isNew ? "(new)" : "(existing)");
     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
       });
     }
     navigationTiming = detectNavigationType();
@@ -1807,37 +1935,40 @@ var Loamly = (() => {
       log("AI detected:", aiDetection);
     }
     initialized = true;
-    if (!userConfig.disableAutoPageview) {
-      pageview();
-    }
-    if (!userConfig.disableBehavioral) {
-      setupAdvancedBehavioralTracking(features);
-    }
-    if (features.behavioralML) {
-      behavioralClassifier = new BehavioralClassifier(1e4);
-      behavioralClassifier.setOnClassify(handleBehavioralClassification);
-      setupBehavioralMLTracking();
-    }
-    if (features.focusBlur) {
-      focusBlurAnalyzer = new FocusBlurAnalyzer();
-      focusBlurAnalyzer.initTracking();
-      setTimeout(() => {
-        if (focusBlurAnalyzer) {
-          handleFocusBlurAnalysis(focusBlurAnalyzer.analyze());
-        }
-      }, 5e3);
-    }
     if (features.agentic) {
       agenticAnalyzer = new AgenticBrowserAnalyzer();
       agenticAnalyzer.init();
     }
-    if (features.ping && visitorId && sessionId) {
-      pingService = new PingService(sessionId, visitorId, VERSION, {
-        interval: DEFAULT_CONFIG.pingInterval,
-        endpoint: endpoint(DEFAULT_CONFIG.endpoints.ping)
-      });
-      pingService.start();
-    }
+    void initializeSession().finally(() => {
+      void registerServiceWorker();
+      if (!userConfig.disableAutoPageview) {
+        pageview();
+      }
+      if (!userConfig.disableBehavioral) {
+        setupAdvancedBehavioralTracking(features);
+      }
+      if (features.behavioralML) {
+        behavioralClassifier = new BehavioralClassifier(1e4);
+        behavioralClassifier.setOnClassify(handleBehavioralClassification);
+        setupBehavioralMLTracking();
+      }
+      if (features.focusBlur) {
+        focusBlurAnalyzer = new FocusBlurAnalyzer();
+        focusBlurAnalyzer.initTracking();
+        setTimeout(() => {
+          if (focusBlurAnalyzer) {
+            handleFocusBlurAnalysis(focusBlurAnalyzer.analyze());
+          }
+        }, 5e3);
+      }
+      if (features.ping && visitorId && sessionId) {
+        pingService = new PingService(sessionId, visitorId, VERSION, {
+          interval: DEFAULT_CONFIG3.pingInterval,
+          endpoint: endpoint(DEFAULT_CONFIG3.endpoints.ping)
+        });
+        pingService.start();
+      }
+    });
     spaRouter = new SPARouter({
       onNavigate: handleSPANavigation
     });
@@ -1846,6 +1977,78 @@ var Loamly = (() => {
     reportHealth("initialized");
     log("Initialization complete");
   }
+  async function registerServiceWorker() {
+    if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) return;
+    if (!config.apiKey || !workspaceId) return;
+    try {
+      const swUrl = new URL("/tracker/loamly-sw.js", window.location.origin);
+      swUrl.searchParams.set("workspace_id", workspaceId);
+      swUrl.searchParams.set("api_key", config.apiKey);
+      const registration = await navigator.serviceWorker.register(swUrl.toString(), { scope: "/" });
+      registration.addEventListener("updatefound", () => {
+        const installing = registration.installing;
+        installing?.addEventListener("statechange", () => {
+          if (installing.state === "activated") {
+            installing.postMessage({ type: "SKIP_WAITING" });
+          }
+        });
+      });
+      setInterval(() => {
+        registration.update().catch(() => {
+        });
+      }, 24 * 60 * 60 * 1e3);
+    } catch {
+    }
+  }
+  async function initializeSession() {
+    const now = Date.now();
+    pageStartTime = now;
+    try {
+      const storedSession = sessionStorage.getItem("loamly_session");
+      const storedStart = sessionStorage.getItem("loamly_start");
+      const sessionTimeout = config.sessionTimeout ?? DEFAULT_CONFIG3.sessionTimeout;
+      if (storedSession && storedStart) {
+        const startTime = parseInt(storedStart, 10);
+        const elapsed = now - startTime;
+        if (elapsed > 0 && elapsed < sessionTimeout) {
+          sessionId = storedSession;
+          log("Session ID:", sessionId, "(existing)");
+          return;
+        }
+      }
+    } catch {
+    }
+    if (config.apiKey && workspaceId && visitorId) {
+      try {
+        const response = await safeFetch(endpoint(DEFAULT_CONFIG3.endpoints.session), {
+          method: "POST",
+          headers: buildHeaders(),
+          body: JSON.stringify({
+            workspace_id: workspaceId,
+            visitor_id: visitorId
+          })
+        });
+        if (response?.ok) {
+          const data = await response.json();
+          sessionId = data.session_id || sessionId;
+          const startTime = data.start_time || now;
+          if (sessionId) {
+            try {
+              sessionStorage.setItem("loamly_session", sessionId);
+              sessionStorage.setItem("loamly_start", String(startTime));
+            } catch {
+            }
+            log("Session ID:", sessionId, "(server)");
+            return;
+          }
+        }
+      } catch {
+      }
+    }
+    const session = getSessionId();
+    sessionId = session.sessionId;
+    log("Session ID:", sessionId, session.isNew ? "(new)" : "(existing)");
+  }
   function setupAdvancedBehavioralTracking(features) {
     if (features.scroll) {
       scrollTracker = new ScrollTracker({
@@ -1853,8 +2056,8 @@ var Loamly = (() => {
         onChunkReached: (event) => {
           log("Scroll chunk:", event.chunk);
           queueEvent("scroll_depth", {
-            depth: event.depth,
-            chunk: event.chunk,
+            scroll_depth: Math.round(event.depth / 100 * 100) / 100,
+            milestone: Math.round(event.chunk / 100 * 100) / 100,
             time_to_reach_ms: event.time_to_reach_ms
           });
         }
@@ -1866,12 +2069,10 @@ 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", {
-              active_time_ms: event.active_time_ms,
-              total_time_ms: event.total_time_ms,
-              idle_time_ms: event.idle_time_ms,
-              is_engaged: event.is_engaged
+              visible_time_ms: event.total_time_ms,
+              page_start_time: pageStartTime || Date.now()
             });
           }
         }
@@ -1882,13 +2083,22 @@ var Loamly = (() => {
       formTracker = new FormTracker({
         onFormEvent: (event) => {
           log("Form event:", event.event_type, event.form_id);
-          queueEvent(event.event_type, {
+          const isSubmitEvent = event.event_type === "form_submit";
+          const isSuccessEvent = event.event_type === "form_success";
+          const normalizedEventType = isSubmitEvent || isSuccessEvent ? "form_submit" : "form_focus";
+          const submitSource = event.submit_source || (isSuccessEvent ? "thank_you" : isSubmitEvent ? "submit" : null);
+          queueEvent(normalizedEventType, {
             form_id: event.form_id,
-            form_type: event.form_type,
-            field_name: event.field_name,
-            field_type: event.field_type,
-            time_to_submit_ms: event.time_to_submit_ms,
-            is_conversion: event.is_conversion
+            form_provider: event.form_type || "unknown",
+            form_field_type: event.field_type || null,
+            form_field_name: event.field_name || null,
+            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,
+            // LOA-482: Include captured form field values
+            fields: event.fields || null,
+            email_submitted: event.email_submitted || null
           });
         }
       });
@@ -1909,7 +2119,7 @@ var Loamly = (() => {
       if (link && link.href) {
         const isExternal = link.hostname !== window.location.hostname;
         queueEvent("click", {
-          element: "link",
+          element_type: "link",
           href: truncateText(link.href, 200),
           text: truncateText(link.textContent || "", 100),
           is_external: isExternal
@@ -1919,15 +2129,32 @@ var Loamly = (() => {
   }
   function queueEvent(eventType, data) {
     if (!eventQueue) return;
-    eventQueue.push(eventType, {
+    if (!config.apiKey) {
+      log("Missing apiKey, behavioral event skipped:", eventType);
+      return;
+    }
+    if (!workspaceId) {
+      log("Missing workspaceId, behavioral event skipped:", eventType);
+      return;
+    }
+    if (!sessionId) {
+      log("Missing sessionId, behavioral event skipped:", eventType);
+      return;
+    }
+    const idempotencyKey = buildIdempotencyKey(eventType);
+    const payload = {
       visitor_id: visitorId,
       session_id: sessionId,
       event_type: eventType,
-      ...data,
-      url: window.location.href,
+      event_data: data,
+      page_url: window.location.href,
+      page_path: window.location.pathname,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      tracker_version: VERSION
-    });
+      tracker_version: VERSION,
+      idempotency_key: idempotencyKey
+    };
+    payload.workspace_id = workspaceId;
+    eventQueue.push(eventType, payload, buildHeaders(idempotencyKey));
   }
   function handleSPANavigation(event) {
     log("SPA navigation:", event.navigation_type, event.to_url);
@@ -1955,34 +2182,42 @@ var Loamly = (() => {
   }
   function setupUnloadHandlers() {
     const handleUnload = () => {
+      if (!workspaceId || !config.apiKey || !sessionId) return;
       const scrollEvent = scrollTracker?.getFinalEvent();
       if (scrollEvent) {
-        sendBeacon(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
+        sendBeacon(buildBeaconUrl(endpoint(DEFAULT_CONFIG3.endpoints.behavioral)), {
+          workspace_id: workspaceId,
           visitor_id: visitorId,
           session_id: sessionId,
           event_type: "scroll_depth_final",
-          data: scrollEvent,
-          url: window.location.href
+          event_data: {
+            scroll_depth: Math.round(scrollEvent.depth / 100 * 100) / 100,
+            milestone: Math.round(scrollEvent.chunk / 100 * 100) / 100,
+            time_to_reach_ms: scrollEvent.time_to_reach_ms
+          },
+          page_url: window.location.href,
+          page_path: window.location.pathname,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tracker_version: VERSION,
+          idempotency_key: buildIdempotencyKey("scroll_depth_final")
         });
       }
       const timeEvent = timeTracker?.getFinalMetrics();
       if (timeEvent) {
-        sendBeacon(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
-          visitor_id: visitorId,
-          session_id: sessionId,
-          event_type: "time_spent_final",
-          data: timeEvent,
-          url: window.location.href
-        });
-      }
-      const agenticResult = agenticAnalyzer?.getResult();
-      if (agenticResult && agenticResult.agenticProbability > 0) {
-        sendBeacon(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
+        sendBeacon(buildBeaconUrl(endpoint(DEFAULT_CONFIG3.endpoints.behavioral)), {
+          workspace_id: workspaceId,
           visitor_id: visitorId,
           session_id: sessionId,
-          event_type: "agentic_detection",
-          data: agenticResult,
-          url: window.location.href
+          event_type: "time_spent",
+          event_data: {
+            visible_time_ms: timeEvent.total_time_ms,
+            page_start_time: pageStartTime || Date.now()
+          },
+          page_url: window.location.href,
+          page_path: window.location.pathname,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          tracker_version: VERSION,
+          idempotency_key: buildIdempotencyKey("time_spent")
         });
       }
       eventQueue?.flushBeacon();
@@ -2005,30 +2240,55 @@ var Loamly = (() => {
       log("Not initialized, call init() first");
       return;
     }
+    if (!config.apiKey) {
+      log("Missing apiKey, pageview skipped");
+      return;
+    }
     const url = customUrl || window.location.href;
+    const utmParams = extractUTMParams(url);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const idempotencyKey = buildIdempotencyKey("visit");
+    const agenticResult = agenticAnalyzer?.getResult();
+    const pagePath = (() => {
+      try {
+        return new URL(url).pathname;
+      } catch {
+        return window.location.pathname;
+      }
+    })();
     const payload = {
       visitor_id: visitorId,
       session_id: sessionId,
-      url,
+      page_url: url,
+      page_path: pagePath,
       referrer: document.referrer || null,
       title: document.title || null,
-      utm_source: extractUTMParams(url).utm_source || null,
-      utm_medium: extractUTMParams(url).utm_medium || null,
-      utm_campaign: extractUTMParams(url).utm_campaign || null,
+      utm_source: utmParams.utm_source || null,
+      utm_medium: utmParams.utm_medium || null,
+      utm_campaign: utmParams.utm_campaign || null,
+      utm_term: utmParams.utm_term || null,
+      utm_content: utmParams.utm_content || null,
       user_agent: navigator.userAgent,
       screen_width: window.screen?.width,
       screen_height: window.screen?.height,
       language: navigator.language,
       timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
       tracker_version: VERSION,
+      event_type: "pageview",
+      event_data: null,
+      timestamp,
       navigation_timing: navigationTiming,
       ai_platform: aiDetection?.platform || null,
-      is_ai_referrer: aiDetection?.isAI || false
+      is_ai_referrer: aiDetection?.isAI || false,
+      agentic_detection: agenticResult || null
     };
+    if (workspaceId) {
+      payload.workspace_id = workspaceId;
+    }
     log("Pageview:", payload);
-    safeFetch(endpoint(DEFAULT_CONFIG.endpoints.visit), {
+    safeFetch(endpoint(DEFAULT_CONFIG3.endpoints.visit), {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: buildHeaders(idempotencyKey),
       body: JSON.stringify(payload)
     });
   }
@@ -2037,6 +2297,11 @@ var Loamly = (() => {
       log("Not initialized, call init() first");
       return;
     }
+    if (!config.apiKey) {
+      log("Missing apiKey, event skipped:", eventName);
+      return;
+    }
+    const idempotencyKey = buildIdempotencyKey(`event:${eventName}`);
     const payload = {
       visitor_id: visitorId,
       session_id: sessionId,
@@ -2045,14 +2310,19 @@ var Loamly = (() => {
       properties: options.properties || {},
       revenue: options.revenue,
       currency: options.currency || "USD",
-      url: window.location.href,
+      page_url: window.location.href,
+      referrer: document.referrer || null,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      tracker_version: VERSION
+      tracker_version: VERSION,
+      idempotency_key: idempotencyKey
     };
+    if (workspaceId) {
+      payload.workspace_id = workspaceId;
+    }
     log("Event:", eventName, payload);
     safeFetch(endpoint("/api/ingest/event"), {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: buildHeaders(idempotencyKey),
       body: JSON.stringify(payload)
     });
   }
@@ -2064,17 +2334,26 @@ var Loamly = (() => {
       log("Not initialized, call init() first");
       return;
     }
+    if (!config.apiKey) {
+      log("Missing apiKey, identify skipped");
+      return;
+    }
     log("Identify:", userId, traits);
+    const idempotencyKey = buildIdempotencyKey("identify");
     const payload = {
       visitor_id: visitorId,
       session_id: sessionId,
       user_id: userId,
       traits,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      idempotency_key: idempotencyKey
     };
+    if (workspaceId) {
+      payload.workspace_id = workspaceId;
+    }
     safeFetch(endpoint("/api/ingest/identify"), {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: buildHeaders(idempotencyKey),
       body: JSON.stringify(payload)
     });
   }
@@ -2205,14 +2484,15 @@ var Loamly = (() => {
     return initialized;
   }
   function reportHealth(status, errorMessage) {
-    if (!config.apiKey) return;
     try {
       const healthData = {
-        workspace_id: config.apiKey,
+        workspace_id: workspaceId,
+        visitor_id: visitorId,
+        session_id: sessionId,
         status,
         error_message: errorMessage || null,
-        version: VERSION,
-        url: typeof window !== "undefined" ? window.location.href : null,
+        tracker_version: VERSION,
+        page_url: typeof window !== "undefined" ? window.location.href : null,
         user_agent: typeof navigator !== "undefined" ? navigator.userAgent : null,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         features: {
@@ -2227,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)
@@ -2271,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,
@@ -2308,16 +2602,17 @@ var Loamly = (() => {
   }
   async function resolveWorkspaceConfig(domain) {
     try {
-      const response = await fetch(`${DEFAULT_CONFIG.apiHost}${DEFAULT_CONFIG.endpoints.resolve}?domain=${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;
       }
       const data = await response.json();
-      if (data.workspace_id) {
+      if (data.workspace_id && data.public_key) {
         return {
-          apiKey: data.workspace_api_key,
-          apiHost: DEFAULT_CONFIG.apiHost
+          apiKey: data.public_key,
+          workspaceId: data.workspace_id,
+          apiHost: DEFAULT_CONFIG3.apiHost
         };
       }
       return null;
@@ -2334,6 +2629,9 @@ var Loamly = (() => {
         if (script.dataset.apiKey) {
           config2.apiKey = script.dataset.apiKey;
         }
+        if (script.dataset.workspaceId) {
+          config2.workspaceId = script.dataset.workspaceId;
+        }
         if (script.dataset.apiHost) {
           config2.apiHost = script.dataset.apiHost;
         }
@@ -2346,7 +2644,7 @@ var Loamly = (() => {
         if (script.dataset.disableBehavioral === "true") {
           config2.disableBehavioral = true;
         }
-        if (config2.apiKey) {
+        if (config2.apiKey || config2.workspaceId) {
           return config2;
         }
       }
@@ -2367,6 +2665,16 @@ var Loamly = (() => {
       loamly.init(dataConfig);
       return;
     }
+    const urlParams = new URLSearchParams(window.location.search);
+    const apiKeyParam = urlParams.get("api_key");
+    const workspaceIdParam = urlParams.get("workspace_id");
+    if (apiKeyParam || workspaceIdParam) {
+      loamly.init({
+        apiKey: apiKeyParam || void 0,
+        workspaceId: workspaceIdParam || void 0
+      });
+      return;
+    }
     const currentDomain = window.location.hostname;
     if (currentDomain && currentDomain !== "localhost") {
       const resolvedConfig = await resolveWorkspaceConfig(currentDomain);