@loamly/tracker 2.0.2 → 2.1.1

package/dist/loamly.iife.global.js

@@ -26,7 +26,7 @@ var Loamly = (() => {
   });
 
   // src/config.ts
-  var VERSION = "2.0.2";
+  var VERSION = "2.1.1";
   var DEFAULT_CONFIG = {
     apiHost: "https://app.loamly.ai",
     endpoints: {
@@ -862,11 +862,12 @@ var Loamly = (() => {
     /**
      * Add event to queue
      */
-    push(type, payload) {
+    push(type, payload, headers) {
       const event = {
         id: this.generateId(),
         type,
         payload,
+        headers,
         timestamp: Date.now(),
         retries: 0
       };
@@ -895,21 +896,25 @@ var Loamly = (() => {
      */
     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) {
+      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 success;
+      return allSent;
     }
     /**
      * Get current queue length
@@ -936,24 +941,38 @@ var Loamly = (() => {
     }
     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
-      };
       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}`);
+        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) {
@@ -1006,6 +1025,7 @@ var Loamly = (() => {
     constructor(sessionId2, visitorId2, version, config2 = {}) {
       this.intervalId = null;
       this.isVisible = true;
+      this.isFocused = true;
       this.currentScrollDepth = 0;
       this.ping = async () => {
         const data = this.getData();
@@ -1024,6 +1044,12 @@ var Loamly = (() => {
       this.handleVisibilityChange = () => {
         this.isVisible = document.visibilityState === "visible";
       };
+      this.handleFocusChange = () => {
+        this.isFocused = typeof document.hasFocus === "function" ? document.hasFocus() : true;
+        if (this.intervalId && this.isVisible && this.isFocused) {
+          this.ping();
+        }
+      };
       this.handleScroll = () => {
         const scrollPercent = Math.round(
           (window.scrollY + window.innerHeight) / document.documentElement.scrollHeight * 100
@@ -1036,12 +1062,16 @@ var Loamly = (() => {
       this.visitorId = visitorId2;
       this.version = version;
       this.pageLoadTime = Date.now();
+      this.isVisible = document.visibilityState === "visible";
+      this.isFocused = typeof document.hasFocus === "function" ? document.hasFocus() : true;
       this.config = {
         interval: DEFAULT_CONFIG.pingInterval,
         endpoint: "",
         ...config2
       };
       document.addEventListener("visibilitychange", this.handleVisibilityChange);
+      window.addEventListener("focus", this.handleFocusChange);
+      window.addEventListener("blur", this.handleFocusChange);
       window.addEventListener("scroll", this.handleScroll, { passive: true });
     }
     /**
@@ -1050,11 +1080,13 @@ var Loamly = (() => {
     start() {
       if (this.intervalId) return;
       this.intervalId = setInterval(() => {
-        if (this.isVisible) {
+        if (this.isVisible && this.isFocused) {
           this.ping();
         }
       }, this.config.interval);
-      this.ping();
+      if (this.isVisible && this.isFocused) {
+        this.ping();
+      }
     }
     /**
      * Stop the ping service
@@ -1065,6 +1097,8 @@ var Loamly = (() => {
         this.intervalId = null;
       }
       document.removeEventListener("visibilitychange", this.handleVisibilityChange);
+      window.removeEventListener("focus", this.handleFocusChange);
+      window.removeEventListener("blur", this.handleFocusChange);
       window.removeEventListener("scroll", this.handleScroll);
     }
     /**
@@ -1085,7 +1119,7 @@ var Loamly = (() => {
         url: window.location.href,
         time_on_page_ms: Date.now() - this.pageLoadTime,
         scroll_depth: this.currentScrollDepth,
-        is_active: this.isVisible,
+        is_active: this.isVisible && this.isFocused,
         tracker_version: this.version
       };
     }
@@ -1392,7 +1426,8 @@ var Loamly = (() => {
           form_id: formId,
           form_type: this.detectFormType(form),
           time_to_submit_ms: startTime ? Date.now() - startTime : void 0,
-          is_conversion: true
+          is_conversion: true,
+          submit_source: "submit"
         });
       };
       this.handleClick = (e) => {
@@ -1407,7 +1442,8 @@ var Loamly = (() => {
               form_id: formId,
               form_type: "hubspot",
               time_to_submit_ms: startTime ? Date.now() - startTime : void 0,
-              is_conversion: true
+              is_conversion: true,
+              submit_source: "click"
             });
           }
         }
@@ -1416,7 +1452,8 @@ var Loamly = (() => {
             event_type: "form_submit",
             form_id: "typeform_embed",
             form_type: "typeform",
-            is_conversion: true
+            is_conversion: true,
+            submit_source: "click"
           });
         }
       };
@@ -1518,7 +1555,8 @@ var Loamly = (() => {
             event_type: "form_success",
             form_id: "page_conversion",
             form_type: "unknown",
-            is_conversion: true
+            is_conversion: true,
+            submit_source: "thank_you"
           });
           break;
         }
@@ -1742,8 +1780,10 @@ var Loamly = (() => {
   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 +1803,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");
@@ -1773,17 +1835,35 @@ var Loamly = (() => {
       ...userConfig,
       apiHost: userConfig.apiHost || DEFAULT_CONFIG.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,
+      forms: true,
+      spa: true,
+      behavioralML: true,
+      focusBlur: true,
+      agentic: true,
+      eventQueue: true,
+      ping: false,
+      // Opt-in only
+      ...userConfig.features
+    };
     log("Initializing Loamly Tracker v" + VERSION);
+    log("Features:", features);
     visitorId = getVisitorId();
     log("Visitor ID:", visitorId);
-    const session = getSessionId();
-    sessionId = session.sessionId;
-    log("Session ID:", sessionId, session.isNew ? "(new)" : "(existing)");
-    eventQueue = new EventQueue(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
-      batchSize: DEFAULT_CONFIG.batchSize,
-      batchTimeout: DEFAULT_CONFIG.batchTimeout
-    });
+    if (features.eventQueue) {
+      eventQueue = new EventQueue(endpoint(DEFAULT_CONFIG.endpoints.behavioral), {
+        batchSize: DEFAULT_CONFIG.batchSize,
+        batchTimeout: DEFAULT_CONFIG.batchTimeout,
+        apiKey: config.apiKey
+      });
+    }
     navigationTiming = detectNavigationType();
     log("Navigation timing:", navigationTiming);
     aiDetection = detectAIFromReferrer(document.referrer) || detectAIFromUTM(window.location.href);
@@ -1791,31 +1871,40 @@ var Loamly = (() => {
       log("AI detected:", aiDetection);
     }
     initialized = true;
-    if (!userConfig.disableAutoPageview) {
-      pageview();
-    }
-    if (!userConfig.disableBehavioral) {
-      setupAdvancedBehavioralTracking();
-    }
-    behavioralClassifier = new BehavioralClassifier(1e4);
-    behavioralClassifier.setOnClassify(handleBehavioralClassification);
-    setupBehavioralMLTracking();
-    focusBlurAnalyzer = new FocusBlurAnalyzer();
-    focusBlurAnalyzer.initTracking();
-    setTimeout(() => {
-      if (focusBlurAnalyzer) {
-        handleFocusBlurAnalysis(focusBlurAnalyzer.analyze());
-      }
-    }, 5e3);
-    agenticAnalyzer = new AgenticBrowserAnalyzer();
-    agenticAnalyzer.init();
-    if (visitorId && sessionId) {
-      pingService = new PingService(sessionId, visitorId, VERSION, {
-        interval: DEFAULT_CONFIG.pingInterval,
-        endpoint: endpoint(DEFAULT_CONFIG.endpoints.ping)
-      });
-      pingService.start();
-    }
+    if (features.agentic) {
+      agenticAnalyzer = new AgenticBrowserAnalyzer();
+      agenticAnalyzer.init();
+    }
+    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_CONFIG.pingInterval,
+          endpoint: endpoint(DEFAULT_CONFIG.endpoints.ping)
+        });
+        pingService.start();
+      }
+    });
     spaRouter = new SPARouter({
       onNavigate: handleSPANavigation
     });
@@ -1824,55 +1913,146 @@ var Loamly = (() => {
     reportHealth("initialized");
     log("Initialization complete");
   }
-  function setupAdvancedBehavioralTracking() {
-    scrollTracker = new ScrollTracker({
-      chunks: [30, 60, 90, 100],
-      onChunkReached: (event) => {
-        log("Scroll chunk:", event.chunk);
-        queueEvent("scroll_depth", {
-          depth: event.depth,
-          chunk: event.chunk,
-          time_to_reach_ms: event.time_to_reach_ms
+  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" });
+          }
         });
-      }
-    });
-    scrollTracker.start();
-    timeTracker = new TimeTracker({
-      updateIntervalMs: 1e4,
-      // Report every 10 seconds
-      onUpdate: (event) => {
-        if (event.active_time_ms >= DEFAULT_CONFIG.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
-          });
+      });
+      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_CONFIG.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;
         }
       }
-    });
-    timeTracker.start();
-    formTracker = new FormTracker({
-      onFormEvent: (event) => {
-        log("Form event:", event.event_type, event.form_id);
-        queueEvent(event.event_type, {
-          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
+    } catch {
+    }
+    if (config.apiKey && workspaceId && visitorId) {
+      try {
+        const response = await safeFetch(endpoint(DEFAULT_CONFIG.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 {
       }
-    });
-    formTracker.start();
+    }
+    const session = getSessionId();
+    sessionId = session.sessionId;
+    log("Session ID:", sessionId, session.isNew ? "(new)" : "(existing)");
+  }
+  function setupAdvancedBehavioralTracking(features) {
+    if (features.scroll) {
+      scrollTracker = new ScrollTracker({
+        chunks: [30, 60, 90, 100],
+        onChunkReached: (event) => {
+          log("Scroll chunk:", event.chunk);
+          queueEvent("scroll_depth", {
+            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
+          });
+        }
+      });
+      scrollTracker.start();
+    }
+    if (features.time) {
+      timeTracker = new TimeTracker({
+        updateIntervalMs: 1e4,
+        // Report every 10 seconds
+        onUpdate: (event) => {
+          if (event.active_time_ms >= DEFAULT_CONFIG.timeSpentThresholdMs) {
+            queueEvent("time_spent", {
+              visible_time_ms: event.total_time_ms,
+              page_start_time: pageStartTime || Date.now()
+            });
+          }
+        }
+      });
+      timeTracker.start();
+    }
+    if (features.forms) {
+      formTracker = new FormTracker({
+        onFormEvent: (event) => {
+          log("Form event:", event.event_type, event.form_id);
+          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_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
+          });
+        }
+      });
+      formTracker.start();
+    }
+    if (features.spa) {
+      spaRouter = new SPARouter({
+        onNavigate: (event) => {
+          log("SPA navigation:", event.navigation_type);
+          pageview(event.to_url);
+        }
+      });
+      spaRouter.start();
+    }
     document.addEventListener("click", (e) => {
       const target = e.target;
       const link = target.closest("a");
       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
@@ -1882,15 +2062,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);
@@ -1918,34 +2115,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_CONFIG.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), {
+        sendBeacon(buildBeaconUrl(endpoint(DEFAULT_CONFIG.endpoints.behavioral)), {
+          workspace_id: workspaceId,
           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), {
-          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();
@@ -1968,30 +2173,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), {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: buildHeaders(idempotencyKey),
       body: JSON.stringify(payload)
     });
   }
@@ -2000,6 +2230,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,
@@ -2008,14 +2243,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)
     });
   }
@@ -2027,17 +2267,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)
     });
   }
@@ -2168,14 +2417,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: {
@@ -2271,15 +2521,16 @@ 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_CONFIG.apiHost}${DEFAULT_CONFIG.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,
+          apiKey: data.public_key,
+          workspaceId: data.workspace_id,
           apiHost: DEFAULT_CONFIG.apiHost
         };
       }
@@ -2297,6 +2548,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;
         }
@@ -2309,7 +2563,7 @@ var Loamly = (() => {
         if (script.dataset.disableBehavioral === "true") {
           config2.disableBehavioral = true;
         }
-        if (config2.apiKey) {
+        if (config2.apiKey || config2.workspaceId) {
           return config2;
         }
       }
@@ -2330,6 +2584,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);