@logspace/sdk 1.0.2 → 1.1.0

package/logspace.esm.js

@@ -27,6 +27,50 @@ function safeStringify(value) {
     if (typeof value === "number" || typeof value === "boolean") return String(value);
     if (value === null) return "null";
     if (value === void 0) return "undefined";
+    if (typeof value === "function") {
+      const name = value.name || "anonymous";
+      return `[Function: ${name}]`;
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    if (value instanceof Error) {
+      return JSON.stringify({
+        name: value.name,
+        message: value.message,
+        stack: value.stack
+      });
+    }
+    if (typeof FormData !== "undefined" && value instanceof FormData) {
+      const formDataObj = {};
+      value.forEach((val, key) => {
+        if (typeof Blob !== "undefined" && val instanceof Blob) {
+          const blobVal = val;
+          const fileInfo = typeof File !== "undefined" && val instanceof File ? `File(${val.name}, ${blobVal.size}b)` : `Blob(${blobVal.size}b)`;
+          if (formDataObj[key]) {
+            const existing = formDataObj[key];
+            formDataObj[key] = Array.isArray(existing) ? [...existing, fileInfo] : [existing, fileInfo];
+          } else {
+            formDataObj[key] = fileInfo;
+          }
+        } else {
+          const strVal = String(val).length > 1e3 ? String(val).substring(0, 1e3) + "..." : String(val);
+          if (formDataObj[key]) {
+            const existing = formDataObj[key];
+            formDataObj[key] = Array.isArray(existing) ? [...existing, strVal] : [existing, strVal];
+          } else {
+            formDataObj[key] = strVal;
+          }
+        }
+      });
+      return JSON.stringify(formDataObj);
+    }
+    if (typeof Blob !== "undefined" && value instanceof Blob) {
+      if (value instanceof File) {
+        return `File(${value.name}, ${value.size}b, ${value.type})`;
+      }
+      return `Blob(${value.size}b, ${value.type})`;
+    }
     const seen = /* @__PURE__ */ new WeakSet();
     return JSON.stringify(value, (key, val) => {
       if (typeof val === "object" && val !== null) {
@@ -65,6 +109,11 @@ function maskSensitiveData(text) {
       pattern: /\b(?:\+?1[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}\b/g,
       replacement: "[PHONE_REDACTED]"
     },
+    // Passwords in plain text logs (e.g., "Password: value", "password: value")
+    {
+      pattern: /\b(password|pwd|passwd)\s*[:=]\s*[^\s,;}\]]+/gi,
+      replacement: "$1: [REDACTED]"
+    },
     // Passwords in JSON (case insensitive)
     {
       pattern: /"password"\s*:\s*"[^"]*"/gi,
@@ -74,7 +123,12 @@ function maskSensitiveData(text) {
       pattern: /'password'\s*:\s*'[^']*'/gi,
       replacement: "'password': '[REDACTED]'"
     },
-    // API keys and tokens
+    // API keys (common prefixes: sk_, pk_, api_key_, etc.)
+    {
+      pattern: /\b(?:sk|pk|api|auth|secret)_(?:live|test|prod|dev)?_[A-Za-z0-9_-]{10,}/g,
+      replacement: "[API_KEY_REDACTED]"
+    },
+    // API keys and tokens in JSON
     {
       pattern: /"(?:api_?key|token|secret|auth_?token|access_?token)"\s*:\s*"[^"]*"/gi,
       replacement: '"$1": "[REDACTED]"'
@@ -92,9 +146,9 @@ function maskSensitiveData(text) {
       pattern: /Authorization:\s*Basic\s+[^\s]+/gi,
       replacement: "Authorization: Basic [REDACTED]"
     },
-    // JWT tokens (rough pattern)
+    // JWT tokens - matches eyJ... pattern (base64url encoded JSON starting with {"alg" or {"typ")
     {
-      pattern: /\b[A-Za-z0-9-_]{36,}\.[A-Za-z0-9-_]{36,}\.[A-Za-z0-9-_]{36,}\b/g,
+      pattern: /\beyJ[A-Za-z0-9_-]*\.eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+\b/g,
       replacement: "[JWT_TOKEN_REDACTED]"
     }
   ];
@@ -103,6 +157,52 @@ function maskSensitiveData(text) {
   }
   return masked;
 }
+const SENSITIVE_LABELS = /^(password|pwd|passwd|secret|token|api[_-]?key|auth[_-]?token|access[_-]?token|private[_-]?key|secret[_-]?key)\s*[:=]?\s*$/i;
+function maskConsoleArgs(args) {
+  const result2 = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const nextArg = args[i + 1];
+    if (typeof arg === "string" && SENSITIVE_LABELS.test(arg.trim()) && nextArg !== void 0) {
+      result2.push(arg);
+      result2.push("[REDACTED]");
+      i++;
+    } else if (arg !== void 0) {
+      result2.push(maskSensitiveData(arg));
+    }
+  }
+  return result2;
+}
+function maskHeaders(headers, additionalHeaders) {
+  if (!headers || typeof headers !== "object") {
+    return headers;
+  }
+  const maskedHeaders = {};
+  const defaultSensitiveHeaders = [
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key",
+    "x-auth-token",
+    "x-access-token",
+    "x-csrf-token",
+    "csrf-token"
+  ];
+  const allSensitiveHeaders = [...defaultSensitiveHeaders, ...(additionalHeaders || []).map((h) => h.toLowerCase())];
+  for (const [name, value] of Object.entries(headers)) {
+    let maskedValue = value;
+    const isSensitiveHeader = allSensitiveHeaders.some(
+      (sensitiveName) => name.toLowerCase().includes(sensitiveName.toLowerCase())
+    );
+    if (isSensitiveHeader) {
+      maskedValue = "[REDACTED]";
+    } else {
+      maskedValue = maskSensitiveData(value);
+    }
+    maskedHeaders[name] = maskedValue;
+  }
+  return maskedHeaders;
+}
 function isBrowser() {
   return typeof window !== "undefined" && typeof document !== "undefined";
 }
@@ -239,7 +339,59 @@ function createLogEntry(type, data, severity = "info") {
     severity
   };
 }
+function applyPrivacy(log, privacy) {
+  if (!privacy.maskSensitiveData) {
+    return log;
+  }
+  const masked = { ...log, data: { ...log.data } };
+  switch (log.type) {
+    case "network":
+      if (masked.data.requestHeaders) {
+        masked.data.requestHeaders = maskHeaders(masked.data.requestHeaders, privacy.redactHeaders);
+      }
+      if (masked.data.responseHeaders) {
+        masked.data.responseHeaders = maskHeaders(masked.data.responseHeaders, privacy.redactHeaders);
+      }
+      if (masked.data.requestBody) {
+        masked.data.requestBody = maskSensitiveData(masked.data.requestBody);
+      }
+      if (masked.data.responseBody) {
+        masked.data.responseBody = maskSensitiveData(masked.data.responseBody);
+      }
+      break;
+    case "console":
+      if (masked.data.args && Array.isArray(masked.data.args)) {
+        masked.data.args = maskConsoleArgs(masked.data.args);
+      }
+      break;
+    case "websocket":
+    case "sse":
+      if (masked.data.message) {
+        masked.data.message = maskSensitiveData(masked.data.message);
+      }
+      break;
+    case "storage":
+      if (masked.data.value) {
+        masked.data.value = maskSensitiveData(masked.data.value);
+      }
+      if (masked.data.oldValue) {
+        masked.data.oldValue = maskSensitiveData(masked.data.oldValue);
+      }
+      break;
+    case "interaction":
+      if (masked.data.value) {
+        masked.data.value = maskSensitiveData(masked.data.value);
+      }
+      if (masked.data.element?.text) {
+        masked.data.element.text = maskSensitiveData(masked.data.element.text);
+      }
+      break;
+  }
+  return masked;
+}
 let originalConsole = null;
+const timerMap = /* @__PURE__ */ new Map();
+const counterMap = /* @__PURE__ */ new Map();
 function shouldIgnoreMessage(args) {
   if (!args || args.length === 0) return false;
   for (const arg of args) {
@@ -275,7 +427,15 @@ const consoleCapture = {
       info: console.info,
       warn: console.warn,
       error: console.error,
-      debug: console.debug
+      debug: console.debug,
+      time: console.time,
+      timeEnd: console.timeEnd,
+      timeLog: console.timeLog,
+      trace: console.trace,
+      table: console.table,
+      count: console.count,
+      countReset: console.countReset,
+      assert: console.assert
     };
     levels.forEach((level) => {
       console[level] = function(...args) {
@@ -303,6 +463,124 @@ const consoleCapture = {
         handler2(log);
       };
     });
+    console.time = function(label = "default") {
+      originalConsole.time.call(console, label);
+      timerMap.set(label, performance.now());
+    };
+    console.timeLog = function(label = "default", ...args) {
+      originalConsole.timeLog.apply(console, [label, ...args]);
+      const startTime = timerMap.get(label);
+      if (startTime === void 0) {
+        return;
+      }
+      const duration = performance.now() - startTime;
+      const serializedArgs = args.map((arg) => safeStringify(arg));
+      const log = createLogEntry(
+        "console",
+        {
+          level: "timeLog",
+          args: [`${label}: ${duration.toFixed(3)}ms`, ...serializedArgs],
+          timerLabel: label,
+          duration
+        },
+        "info"
+      );
+      handler2(log);
+    };
+    console.timeEnd = function(label = "default") {
+      originalConsole.timeEnd.call(console, label);
+      const startTime = timerMap.get(label);
+      if (startTime === void 0) {
+        return;
+      }
+      const duration = performance.now() - startTime;
+      timerMap.delete(label);
+      const log = createLogEntry(
+        "console",
+        {
+          level: "timeEnd",
+          args: [`${label}: ${duration.toFixed(3)}ms`],
+          timerLabel: label,
+          duration
+        },
+        "info"
+      );
+      handler2(log);
+    };
+    console.trace = function(...args) {
+      originalConsole.trace.apply(console, args);
+      const serializedArgs = args.map((arg) => safeStringify(arg));
+      const stackTrace = new Error().stack || "";
+      const log = createLogEntry(
+        "console",
+        {
+          level: "trace",
+          args: serializedArgs.length > 0 ? serializedArgs : ["Trace"],
+          stackTrace
+        },
+        "info"
+      );
+      handler2(log);
+    };
+    console.table = function(data, columns) {
+      originalConsole.table.call(console, data, columns);
+      const log = createLogEntry(
+        "console",
+        {
+          level: "table",
+          args: [safeStringify(data)],
+          columns
+        },
+        "info"
+      );
+      handler2(log);
+    };
+    console.count = function(label = "default") {
+      originalConsole.count.call(console, label);
+      const count = (counterMap.get(label) || 0) + 1;
+      counterMap.set(label, count);
+      const log = createLogEntry(
+        "console",
+        {
+          level: "count",
+          args: [`${label}: ${count}`],
+          counterLabel: label,
+          count
+        },
+        "info"
+      );
+      handler2(log);
+    };
+    console.countReset = function(label = "default") {
+      originalConsole.countReset.call(console, label);
+      counterMap.set(label, 0);
+      const log = createLogEntry(
+        "console",
+        {
+          level: "countReset",
+          args: [`${label}: 0`],
+          counterLabel: label
+        },
+        "info"
+      );
+      handler2(log);
+    };
+    console.assert = function(condition, ...args) {
+      originalConsole.assert.apply(console, [condition, ...args]);
+      if (!condition) {
+        const serializedArgs = args.map((arg) => safeStringify(arg));
+        const log = createLogEntry(
+          "console",
+          {
+            level: "assert",
+            args: ["Assertion failed:", ...serializedArgs],
+            stackTrace: new Error().stack
+          },
+          "warn"
+        );
+        handler2(log);
+      }
+    };
   },
   uninstall() {
     if (!isBrowser() || !originalConsole) return;
@@ -311,10 +589,21 @@ const consoleCapture = {
     console.warn = originalConsole.warn;
     console.error = originalConsole.error;
     console.debug = originalConsole.debug;
+    console.time = originalConsole.time;
+    console.timeEnd = originalConsole.timeEnd;
+    console.timeLog = originalConsole.timeLog;
+    console.trace = originalConsole.trace;
+    console.table = originalConsole.table;
+    console.count = originalConsole.count;
+    console.countReset = originalConsole.countReset;
+    console.assert = originalConsole.assert;
+    timerMap.clear();
+    counterMap.clear();
     originalConsole = null;
   }
 };
-const MAX_BODY_SIZE = 5e3;
+const DEFAULT_MAX_BODY_SIZE = 10 * 1024;
+let maxBodySize$2 = DEFAULT_MAX_BODY_SIZE;
 let originalFetch = null;
 let OriginalXHR = null;
 let excludeUrls$3 = [];
@@ -409,12 +698,13 @@ function interceptSSEStream(response, url, handler2) {
 }
 const networkCapture = {
   name: "network",
-  install(handler2, privacy) {
+  install(handler2, privacy, _onActivity, limits) {
     if (!isBrowser()) return;
     if (originalFetch) return;
     captureHandler$1 = handler2;
     excludeUrls$3 = privacy.excludeUrls || [];
     const blockBodies = privacy.blockNetworkBodies || [];
+    maxBodySize$2 = limits?.maxNetworkBodySize ? limits.maxNetworkBodySize * 1024 : DEFAULT_MAX_BODY_SIZE;
     originalFetch = window.fetch;
     window.fetch = async function(...args) {
       const startTime = performance.now();
@@ -444,7 +734,7 @@ const networkCapture = {
       let requestBody;
       if (!shouldBlockBody && options.body) {
         const bodyStr = safeStringify(options.body);
-        requestBody = bodyStr.length > MAX_BODY_SIZE ? bodyStr.substring(0, MAX_BODY_SIZE) + "..." : bodyStr;
+        requestBody = bodyStr.length > maxBodySize$2 ? bodyStr.substring(0, maxBodySize$2) + "..." : bodyStr;
       }
       try {
         const response = await originalFetch(...args);
@@ -455,9 +745,9 @@ const networkCapture = {
         let responseBody;
         let responseSize;
         try {
-          if (!shouldBlockBody && (contentType.includes("application/json") || contentType.includes("text/plain") || contentType.includes("text/html"))) {
+          if (!shouldBlockBody && (contentType.includes("application/json") || contentType.includes("text/plain") || contentType.includes("text/html") || contentType.includes("text/x-component"))) {
             const text = await clonedResponse.text();
-            responseBody = text.length > MAX_BODY_SIZE ? text.substring(0, MAX_BODY_SIZE) + "..." : text;
+            responseBody = text.length > maxBodySize$2 ? text.substring(0, maxBodySize$2) + "..." : text;
             responseSize = new Blob([responseBody]).size;
           } else if (contentLength) {
             responseSize = parseInt(contentLength, 10);
@@ -478,7 +768,7 @@ const networkCapture = {
           {
             method,
             url,
-            status: response.status,
+            statusCode: response.status,
             requestHeaders,
             responseHeaders: Object.fromEntries(response.headers.entries()),
             requestBody,
@@ -524,7 +814,7 @@ const networkCapture = {
           {
             method,
             url,
-            status: 0,
+            statusCode: 0,
             requestHeaders,
             responseHeaders: {},
             requestBody,
@@ -563,7 +853,7 @@ const networkCapture = {
       xhr.send = function(body) {
         if (body && !shouldExcludeUrl(url, excludeUrls$3)) {
           const bodyStr = safeStringify(body);
-          requestBody = bodyStr.length > MAX_BODY_SIZE ? bodyStr.substring(0, MAX_BODY_SIZE) + "..." : bodyStr;
+          requestBody = bodyStr.length > maxBodySize$2 ? bodyStr.substring(0, maxBodySize$2) + "..." : bodyStr;
         }
         return originalSend.apply(this, [body]);
       };
@@ -596,7 +886,7 @@ const networkCapture = {
         }
         let responseBody;
         let responseSize;
-        if (contentType.includes("application/json") || contentType.includes("text/plain") || contentType.includes("text/html")) {
+        if (contentType.includes("application/json") || contentType.includes("text/plain") || contentType.includes("text/html") || contentType.includes("text/x-component")) {
           try {
             let responseText;
             if (xhr.responseType === "" || xhr.responseType === "text") {
@@ -607,7 +897,7 @@ const networkCapture = {
               responseText = "";
             }
             if (responseText) {
-              responseBody = responseText.length > MAX_BODY_SIZE ? responseText.substring(0, MAX_BODY_SIZE) + "..." : responseText;
+              responseBody = responseText.length > maxBodySize$2 ? responseText.substring(0, maxBodySize$2) + "..." : responseText;
               responseSize = new Blob([responseBody]).size;
             }
           } catch {
@@ -628,7 +918,7 @@ const networkCapture = {
           {
             method,
             url,
-            status: xhr.status,
+            statusCode: xhr.status,
             requestHeaders,
             responseHeaders,
             requestBody,
@@ -684,10 +974,20 @@ const errorCapture = {
     };
     window.addEventListener("error", errorHandler$1, true);
     rejectionHandler = (event) => {
+      let reasonMessage;
+      if (event.reason instanceof Error) {
+        reasonMessage = event.reason.message || event.reason.toString();
+      } else if (typeof event.reason === "string") {
+        reasonMessage = event.reason;
+      } else if (event.reason && typeof event.reason === "object") {
+        reasonMessage = event.reason.message || safeStringify(event.reason);
+      } else {
+        reasonMessage = safeStringify(event.reason);
+      }
       const log = createLogEntry(
         "error",
         {
-          message: `Unhandled Promise Rejection: ${safeStringify(event.reason)}`,
+          message: `Unhandled Promise Rejection: ${reasonMessage}`,
           stack: event.reason?.stack || "",
           context: {},
           isUncaught: true
@@ -712,6 +1012,7 @@ const errorCapture = {
 };
 let OriginalWebSocket = null;
 let excludeUrls$2 = [];
+let maxBodySize$1 = 10 * 1024;
 const wsThrottleMap = /* @__PURE__ */ new Map();
 const THROTTLE_WINDOW = 1e3;
 const MIN_THROTTLE_MS = 100;
@@ -747,12 +1048,15 @@ function shouldCaptureMessage$1(ws, direction) {
   }
   return shouldCapture;
 }
+let activityCallback$1;
 const websocketCapture = {
   name: "websocket",
-  install(handler2, privacy) {
+  install(handler2, privacy, onActivity, limits) {
     if (!isBrowser()) return;
     if (OriginalWebSocket) return;
     excludeUrls$2 = privacy.excludeUrls || [];
+    activityCallback$1 = onActivity;
+    maxBodySize$1 = limits?.maxNetworkBodySize ? limits.maxNetworkBodySize * 1024 : 10 * 1024;
     OriginalWebSocket = window.WebSocket;
     window.WebSocket = function(url, protocols) {
       const ws = new OriginalWebSocket(url, protocols);
@@ -770,9 +1074,10 @@ const websocketCapture = {
         handler2(log);
       });
       ws.addEventListener("message", (event) => {
+        activityCallback$1?.();
         if (!shouldCaptureMessage$1(ws, "received")) return;
         const isBinary = event.data instanceof ArrayBuffer || event.data instanceof Blob;
-        const { content, size } = truncateMessage(event.data, isBinary);
+        const { content, size } = truncateMessage(event.data, isBinary, maxBodySize$1);
         const log = createLogEntry("websocket", {
           url: wsUrl,
           event: "message",
@@ -787,9 +1092,10 @@ const websocketCapture = {
       });
       const originalSend = ws.send.bind(ws);
       ws.send = function(data) {
+        activityCallback$1?.();
         if (shouldCaptureMessage$1(ws, "sent")) {
           const isBinary = data instanceof ArrayBuffer || data instanceof Blob;
-          const { content, size } = truncateMessage(data, isBinary);
+          const { content, size } = truncateMessage(data, isBinary, maxBodySize$1);
           const log = createLogEntry("websocket", {
             url: wsUrl,
             event: "message",
@@ -852,6 +1158,7 @@ const websocketCapture = {
 };
 let OriginalEventSource = null;
 let excludeUrls$1 = [];
+let maxBodySize = 10 * 1024;
 const sseThrottleMap = /* @__PURE__ */ new Map();
 const SSE_THROTTLE_MS = 100;
 function shouldCaptureMessage(eventSource) {
@@ -868,13 +1175,16 @@ function shouldCaptureMessage(eventSource) {
   }
   return false;
 }
+let activityCallback;
 const sseCapture = {
   name: "sse",
-  install(handler2, privacy) {
+  install(handler2, privacy, onActivity, limits) {
     if (!isBrowser()) return;
     if (!window.EventSource) return;
     if (OriginalEventSource) return;
     excludeUrls$1 = privacy.excludeUrls || [];
+    activityCallback = onActivity;
+    maxBodySize = limits?.maxNetworkBodySize ? limits.maxNetworkBodySize * 1024 : 10 * 1024;
     OriginalEventSource = window.EventSource;
     window.EventSource = function(url, eventSourceInitDict) {
       const eventSource = new OriginalEventSource(url, eventSourceInitDict);
@@ -892,8 +1202,9 @@ const sseCapture = {
         handler2(log);
       });
       eventSource.addEventListener("message", (event) => {
+        activityCallback?.();
         if (!shouldCaptureMessage(eventSource)) return;
-        const { content, size } = truncateMessage(event.data, false);
+        const { content, size } = truncateMessage(event.data, false, maxBodySize);
         const log = createLogEntry("sse", {
           url: sseUrl,
           event: "message",
@@ -971,10 +1282,33 @@ const storageCapture = {
     if (originalStorage) return;
     captureHandler = handler2;
     originalStorage = {
+      getItem: Storage.prototype.getItem,
       setItem: Storage.prototype.setItem,
       removeItem: Storage.prototype.removeItem,
       clear: Storage.prototype.clear
     };
+    Storage.prototype.getItem = function(key) {
+      const isSessionStorage = this === sessionStorage;
+      if (isLogging || key.startsWith("__logspace")) {
+        return originalStorage.getItem.call(this, key);
+      }
+      const value = originalStorage.getItem.call(this, key);
+      try {
+        isLogging = true;
+        const storageType = isSessionStorage ? "sessionStorage" : "localStorage";
+        const log = createLogEntry("storage", {
+          storageType,
+          operation: "getItem",
+          key,
+          value: value ? truncateValue(value).content : null,
+          valueSize: value ? new Blob([value]).size : 0
+        });
+        handler2(log);
+      } finally {
+        isLogging = false;
+      }
+      return value;
+    };
     Storage.prototype.setItem = function(key, value) {
       const isSessionStorage = this === sessionStorage;
       if (isLogging || key.startsWith("__logspace")) {
@@ -1063,6 +1397,7 @@ const storageCapture = {
   uninstall() {
     if (!isBrowser()) return;
     if (originalStorage) {
+      Storage.prototype.getItem = originalStorage.getItem;
       Storage.prototype.setItem = originalStorage.setItem;
       Storage.prototype.removeItem = originalStorage.removeItem;
       Storage.prototype.clear = originalStorage.clear;
@@ -1200,6 +1535,10 @@ let fidObserver = null;
 let clsObserver = null;
 let fcpObserver = null;
 let inpObserver = null;
+let visibilityHandler = null;
+let loadHandler = null;
+let sendVitalsTimeout = null;
+let navigationTimingTimeout = null;
 const metrics = {
   lcp: null,
   fid: null,
@@ -1345,17 +1684,19 @@ const performanceCapture = {
         inpObserver.observe({ type: "event", buffered: true, durationThreshold: 16 });
       } catch {
       }
-      window.addEventListener("visibilitychange", () => {
+      visibilityHandler = () => {
         if (document.visibilityState === "hidden") {
           sendWebVitals();
         }
-      });
-      window.addEventListener("load", () => {
-        setTimeout(() => {
+      };
+      window.addEventListener("visibilitychange", visibilityHandler);
+      loadHandler = () => {
+        navigationTimingTimeout = setTimeout(() => {
           sendNavigationTiming();
         }, 0);
-      });
-      setTimeout(() => {
+      };
+      window.addEventListener("load", loadHandler);
+      sendVitalsTimeout = setTimeout(() => {
         sendWebVitals();
       }, 1e4);
     } catch {
@@ -1368,6 +1709,22 @@ const performanceCapture = {
         observer.disconnect();
       }
     });
+    if (visibilityHandler) {
+      window.removeEventListener("visibilitychange", visibilityHandler);
+      visibilityHandler = null;
+    }
+    if (loadHandler) {
+      window.removeEventListener("load", loadHandler);
+      loadHandler = null;
+    }
+    if (sendVitalsTimeout) {
+      clearTimeout(sendVitalsTimeout);
+      sendVitalsTimeout = null;
+    }
+    if (navigationTimingTimeout) {
+      clearTimeout(navigationTimingTimeout);
+      navigationTimingTimeout = null;
+    }
     lcpObserver = null;
     fidObserver = null;
     clsObserver = null;
@@ -1388,6 +1745,71 @@ let resourceObserver = null;
 let excludeUrls = [];
 const loggedResources = /* @__PURE__ */ new Set();
 let handler$1 = null;
+const fontUrlToFamilyMap = /* @__PURE__ */ new Map();
+function buildFontFamilyMap() {
+  if (!isBrowser()) return;
+  try {
+    for (const sheet of Array.from(document.styleSheets)) {
+      try {
+        if (!sheet.cssRules) continue;
+        for (const rule2 of Array.from(sheet.cssRules)) {
+          if (rule2 instanceof CSSFontFaceRule) {
+            const fontFamily = rule2.style.getPropertyValue("font-family").replace(/["']/g, "").trim();
+            const src = rule2.style.getPropertyValue("src");
+            if (fontFamily && src) {
+              const urlMatches = src.matchAll(/url\(["']?([^"')]+)["']?\)/g);
+              for (const match of urlMatches) {
+                if (match[1]) {
+                  try {
+                    const absoluteUrl = new URL(match[1], sheet.href || window.location.href).href;
+                    fontUrlToFamilyMap.set(absoluteUrl, fontFamily);
+                    fontUrlToFamilyMap.set(match[1], fontFamily);
+                  } catch {
+                    fontUrlToFamilyMap.set(match[1], fontFamily);
+                  }
+                }
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function getFontFamilyForUrl(url) {
+  if (fontUrlToFamilyMap.has(url)) {
+    return fontUrlToFamilyMap.get(url);
+  }
+  try {
+    const urlObj = new URL(url);
+    const filename = urlObj.pathname.split("/").pop();
+    if (filename) {
+      for (const [mapUrl, family] of fontUrlToFamilyMap.entries()) {
+        if (mapUrl.endsWith(filename) || mapUrl.includes(filename)) {
+          return family;
+        }
+      }
+    }
+  } catch {
+  }
+  if ("fonts" in document) {
+    try {
+      const urlLower = url.toLowerCase();
+      for (const font of document.fonts) {
+        if (font.status === "loaded") {
+          const family = font.family.replace(/["']/g, "");
+          if (urlLower.includes(family.toLowerCase().replace(/\s+/g, ""))) {
+            return family;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
 function getResourceType(entry) {
   const initiatorType = entry.initiatorType || "other";
   const url = entry.name;
@@ -1442,13 +1864,14 @@ function processResourceEntry(entry) {
   } else if (duration > 1e3) {
     severity = "warn";
   }
+  const fontFamily = resourceType === "font" ? getFontFamilyForUrl(entry.name) : void 0;
   const log = createLogEntry(
     "network",
     {
       method: "GET",
       // Resource loads are always GET
       url: entry.name,
-      status: 200,
+      statusCode: 200,
       // Resources that successfully load return 200
       resourceType,
       initiatorType: entry.initiatorType,
@@ -1457,6 +1880,8 @@ function processResourceEntry(entry) {
       decodedBodySize,
       encodedBodySize,
       cached,
+      // Font family name (only for font resources)
+      ...fontFamily && { fontFamily },
       // Timing breakdown
       timing: {
         dns: Math.round(entry.domainLookupEnd - entry.domainLookupStart),
@@ -1480,11 +1905,13 @@ const resourceCapture = {
     handler$1 = captureHandler2;
     excludeUrls = privacy.excludeUrls || [];
     try {
+      buildFontFamilyMap();
       const existingResources = performance.getEntriesByType("resource");
       existingResources.forEach((entry) => {
         processResourceEntry(entry);
       });
       resourceObserver = new PerformanceObserver((list2) => {
+        buildFontFamilyMap();
         const entries = list2.getEntries();
         entries.forEach((entry) => {
           processResourceEntry(entry);
@@ -1507,6 +1934,7 @@ const resourceCapture = {
    */
   reset() {
     loggedResources.clear();
+    fontUrlToFamilyMap.clear();
   }
 };
 let originalPushState = null;
@@ -13758,7 +14186,7 @@ const state = {
   stopFn: null,
   startTime: null
 };
-let currentTabId = null;
+let currentTabId$1 = null;
 const DEFAULT_CONFIG$1 = {
   maskAllInputs: false,
   inlineStylesheet: true,
@@ -13786,7 +14214,7 @@ function startRRWebRecording(config2 = {}, onEvent, tabId) {
     return false;
   }
   const mergedConfig = { ...DEFAULT_CONFIG$1, ...config2 };
-  currentTabId = tabId || null;
+  currentTabId$1 = tabId || null;
   try {
     state.events = [];
     state.startTime = Date.now();
@@ -13795,7 +14223,7 @@ function startRRWebRecording(config2 = {}, onEvent, tabId) {
       emit: (event, isCheckout) => {
         const tabAwareEvent = {
           ...event,
-          tabId: currentTabId || void 0
+          tabId: currentTabId$1 || void 0
         };
         state.events.push(tabAwareEvent);
         onEvent?.(tabAwareEvent);
@@ -13855,427 +14283,41 @@ function addRRWebCustomEvent(tag, payload) {
     console.warn("[LogSpace] Failed to add custom event:", error);
   }
 }
-const LEADER_KEY = "__logspace_leader";
-const SESSION_KEY = "__logspace_session";
-const CHANNEL_NAME = "logspace-multi-tab";
-const HEARTBEAT_INTERVAL = 2e3;
-const HEARTBEAT_STALE_THRESHOLD = 5e3;
-const LEADER_CHECK_INTERVAL = 3e3;
-class MultiTabCoordinator {
-  constructor() {
-    this.channel = null;
-    this.isLeader = false;
-    this.callbacks = null;
-    this.heartbeatTimer = null;
-    this.leaderCheckTimer = null;
-    this.currentSessionId = null;
-    this.initialized = false;
-    this.debug = false;
-    this.tabId = this.generateTabId();
-  }
-  /**
-   * Generate unique tab identifier
-   */
-  generateTabId() {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substring(2, 8);
-    return `tab_${timestamp}_${random}`;
-  }
-  /**
-   * Check if BroadcastChannel is supported
-   */
-  isSupported() {
-    return typeof BroadcastChannel !== "undefined" && typeof localStorage !== "undefined";
-  }
-  /**
-   * Initialize the multi-tab coordinator
-   */
-  init(callbacks, debug = false) {
-    if (this.initialized) return;
-    if (!this.isSupported()) {
-      if (debug) console.log("[LogSpace MultiTab] BroadcastChannel not supported, running single-tab mode");
-      return;
-    }
-    this.callbacks = callbacks;
-    this.debug = debug;
-    this.initialized = true;
-    this.channel = new BroadcastChannel(CHANNEL_NAME);
-    this.channel.onmessage = (event) => this.handleMessage(event.data);
-    window.addEventListener("beforeunload", () => this.handleUnload());
-    this.electLeader();
-    if (this.debug) {
-      console.log("[LogSpace MultiTab] Initialized", { tabId: this.tabId, isLeader: this.isLeader });
-    }
+const DB_NAME = "logspace-sdk-db";
+const DB_VERSION = 1;
+const STORES = {
+  PENDING_SESSIONS: "pending_sessions",
+  // Sessions waiting to be sent
+  CURRENT_SESSION: "current_session"
+  // Current active session backup
+};
+let db = null;
+let dbInitPromise = null;
+async function initDB() {
+  if (dbInitPromise) {
+    return dbInitPromise;
   }
-  /**
-   * Attempt to become leader or join as follower
-   */
-  electLeader() {
-    const existingLeader = this.getLeaderState();
-    if (existingLeader && !this.isLeaderStale(existingLeader)) {
-      this.becomeFollower(existingLeader.sessionId);
-    } else {
-      this.tryBecomeLeader();
-    }
+  if (db) {
+    return db;
   }
-  /**
-   * Try to claim leadership
-   */
-  tryBecomeLeader() {
-    const existingSession = this.getSessionState();
-    const sessionId = existingSession?.id || this.generateSessionId();
-    const isNewSession = !existingSession;
-    const leaderState = {
-      tabId: this.tabId,
-      sessionId,
-      heartbeat: Date.now()
+  dbInitPromise = new Promise((resolve2, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => {
+      dbInitPromise = null;
+      reject(new Error("Failed to open IndexedDB"));
     };
-    try {
-      localStorage.setItem(LEADER_KEY, JSON.stringify(leaderState));
-      const verified = this.getLeaderState();
-      if (verified?.tabId === this.tabId) {
-        this.becomeLeader(sessionId, isNewSession);
-      } else {
-        this.becomeFollower(verified.sessionId);
-      }
-    } catch (error) {
-      if (this.debug) console.warn("[LogSpace MultiTab] Failed to claim leadership:", error);
-    }
-  }
-  /**
-   * Become the leader tab
-   */
-  becomeLeader(sessionId, isNewSession) {
-    this.isLeader = true;
-    this.currentSessionId = sessionId;
-    if (isNewSession) {
-      const sessionState = {
-        id: sessionId,
-        startTime: Date.now()
-      };
-      localStorage.setItem(SESSION_KEY, JSON.stringify(sessionState));
-    }
-    this.startHeartbeat();
-    this.broadcast({ type: "leader-announce", tabId: this.tabId, sessionId });
-    this.callbacks?.onBecomeLeader(sessionId, isNewSession);
-    if (this.debug) {
-      console.log("[LogSpace MultiTab] Became leader", { sessionId, isNewSession });
-    }
-  }
-  /**
-   * Become a follower tab
-   */
-  becomeFollower(sessionId) {
-    this.isLeader = false;
-    this.currentSessionId = sessionId;
-    this.stopHeartbeat();
-    this.startLeaderCheck();
-    this.callbacks?.onBecomeFollower(sessionId);
-    if (this.debug) {
-      console.log("[LogSpace MultiTab] Became follower", { sessionId });
-    }
-  }
-  /**
-   * Handle incoming broadcast messages
-   */
-  handleMessage(message) {
-    if (this.debug) {
-      console.log("[LogSpace MultiTab] Received message:", message.type);
-    }
-    switch (message.type) {
-      case "leader-announce":
-        if (message.tabId !== this.tabId) {
-          if (this.isLeader) {
-            this.becomeFollower(message.sessionId);
-          }
-          this.callbacks?.onLeaderChanged(message.tabId);
-        }
-        break;
-      case "leader-leaving":
-        if (!this.isLeader) {
-          if (this.debug) {
-            console.log("[LogSpace MultiTab] Leader leaving, attempting to claim leadership");
-          }
-          setTimeout(() => this.tryBecomeLeader(), Math.random() * 100);
-        }
-        break;
-      case "log":
-        if (this.isLeader && message.tabId !== this.tabId) {
-          this.callbacks?.onReceiveLog(message.log);
-        }
-        break;
-      case "rrweb-event":
-        if (this.isLeader && message.tabId !== this.tabId) {
-          this.callbacks?.onReceiveRRWebEvent(message.event);
-        }
-        break;
-      case "request-session":
-        if (this.isLeader && message.tabId !== this.tabId) {
-          const session2 = this.getSessionState();
-          if (session2) {
-            this.broadcast({
-              type: "session-info",
-              sessionId: session2.id,
-              startTime: session2.startTime
-            });
-          }
-        }
-        break;
-      case "session-info":
-        if (!this.isLeader) {
-          this.currentSessionId = message.sessionId;
-        }
-        break;
-    }
-  }
-  /**
-   * Start heartbeat for leader
-   */
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.stopLeaderCheck();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.isLeader) {
-        this.updateHeartbeat();
+    request.onsuccess = () => {
+      db = request.result;
+      resolve2(db);
+    };
+    request.onupgradeneeded = (event) => {
+      const database = event.target.result;
+      if (!database.objectStoreNames.contains(STORES.PENDING_SESSIONS)) {
+        const pendingStore = database.createObjectStore(STORES.PENDING_SESSIONS, { keyPath: "id" });
+        pendingStore.createIndex("by-created", "createdAt");
       }
-    }, HEARTBEAT_INTERVAL);
-    this.updateHeartbeat();
-  }
-  /**
-   * Stop heartbeat timer
-   */
-  stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-  }
-  /**
-   * Update heartbeat in localStorage
-   */
-  updateHeartbeat() {
-    const state2 = this.getLeaderState();
-    if (state2 && state2.tabId === this.tabId) {
-      state2.heartbeat = Date.now();
-      try {
-        localStorage.setItem(LEADER_KEY, JSON.stringify(state2));
-      } catch (error) {
-      }
-    }
-  }
-  /**
-   * Start checking if leader is alive (for followers)
-   */
-  startLeaderCheck() {
-    this.stopLeaderCheck();
-    this.leaderCheckTimer = setInterval(() => {
-      if (!this.isLeader) {
-        const leader = this.getLeaderState();
-        if (!leader || this.isLeaderStale(leader)) {
-          if (this.debug) {
-            console.log("[LogSpace MultiTab] Leader appears dead, attempting takeover");
-          }
-          this.tryBecomeLeader();
-        }
-      }
-    }, LEADER_CHECK_INTERVAL);
-  }
-  /**
-   * Stop leader check timer
-   */
-  stopLeaderCheck() {
-    if (this.leaderCheckTimer) {
-      clearInterval(this.leaderCheckTimer);
-      this.leaderCheckTimer = null;
-    }
-  }
-  /**
-   * Check if leader heartbeat is stale
-   */
-  isLeaderStale(leader) {
-    return Date.now() - leader.heartbeat > HEARTBEAT_STALE_THRESHOLD;
-  }
-  /**
-   * Get leader state from localStorage
-   */
-  getLeaderState() {
-    try {
-      const data = localStorage.getItem(LEADER_KEY);
-      return data ? JSON.parse(data) : null;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Get session state from localStorage
-   */
-  getSessionState() {
-    try {
-      const data = localStorage.getItem(SESSION_KEY);
-      return data ? JSON.parse(data) : null;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Generate session ID
-   */
-  generateSessionId() {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substring(2, 10);
-    return `sdk_${timestamp}_${random}`;
-  }
-  /**
-   * Broadcast message to other tabs
-   */
-  broadcast(message) {
-    if (this.channel) {
-      this.channel.postMessage(message);
-    }
-  }
-  /**
-   * Handle page unload - clean leader handoff
-   */
-  handleUnload() {
-    if (this.isLeader) {
-      this.broadcast({ type: "leader-leaving", tabId: this.tabId });
-      try {
-        localStorage.removeItem(LEADER_KEY);
-      } catch {
-      }
-    }
-    this.cleanup();
-  }
-  /**
-   * Send log to leader (for follower tabs)
-   */
-  sendLog(log) {
-    if (!this.initialized || !this.channel) return;
-    if (this.isLeader) {
-      this.callbacks?.onReceiveLog(log);
-    } else {
-      this.broadcast({ type: "log", tabId: this.tabId, log });
-    }
-  }
-  /**
-   * Send rrweb event to leader (for follower tabs)
-   */
-  sendRRWebEvent(event) {
-    if (!this.initialized || !this.channel) return;
-    if (this.isLeader) {
-      this.callbacks?.onReceiveRRWebEvent(event);
-    } else {
-      this.broadcast({ type: "rrweb-event", tabId: this.tabId, event });
-    }
-  }
-  /**
-   * Update session user info (stored in localStorage for all tabs)
-   */
-  updateSessionUser(userId, traits) {
-    const session2 = this.getSessionState();
-    if (session2) {
-      session2.userId = userId;
-      session2.userTraits = traits;
-      try {
-        localStorage.setItem(SESSION_KEY, JSON.stringify(session2));
-      } catch {
-      }
-    }
-  }
-  /**
-   * End session and clear shared state
-   */
-  endSession() {
-    try {
-      localStorage.removeItem(SESSION_KEY);
-      if (this.isLeader) {
-        localStorage.removeItem(LEADER_KEY);
-      }
-    } catch {
-    }
-  }
-  /**
-   * Get current tab ID
-   */
-  getTabId() {
-    return this.tabId;
-  }
-  /**
-   * Get current session ID
-   */
-  getSessionId() {
-    return this.currentSessionId;
-  }
-  /**
-   * Check if this tab is the leader
-   */
-  isLeaderTab() {
-    return this.isLeader;
-  }
-  /**
-   * Check if multi-tab mode is active
-   */
-  isActive() {
-    return this.initialized && this.channel !== null;
-  }
-  /**
-   * Clean up resources
-   */
-  cleanup() {
-    this.stopHeartbeat();
-    this.stopLeaderCheck();
-    if (this.channel) {
-      this.channel.close();
-      this.channel = null;
-    }
-    this.initialized = false;
-  }
-  /**
-   * Force become leader (for testing or recovery)
-   */
-  forceLeadership() {
-    if (!this.initialized) return;
-    const session2 = this.getSessionState();
-    const sessionId = session2?.id || this.generateSessionId();
-    this.becomeLeader(sessionId, !session2);
-  }
-}
-const multiTabCoordinator = new MultiTabCoordinator();
-const DB_NAME = "logspace-sdk-db";
-const DB_VERSION = 1;
-const STORES = {
-  PENDING_SESSIONS: "pending_sessions",
-  // Sessions waiting to be sent
-  CURRENT_SESSION: "current_session"
-  // Current active session backup
-};
-let db = null;
-let dbInitPromise = null;
-async function initDB() {
-  if (dbInitPromise) {
-    return dbInitPromise;
-  }
-  if (db) {
-    return db;
-  }
-  dbInitPromise = new Promise((resolve2, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
-    request.onerror = () => {
-      dbInitPromise = null;
-      reject(new Error("Failed to open IndexedDB"));
-    };
-    request.onsuccess = () => {
-      db = request.result;
-      resolve2(db);
-    };
-    request.onupgradeneeded = (event) => {
-      const database = event.target.result;
-      if (!database.objectStoreNames.contains(STORES.PENDING_SESSIONS)) {
-        const pendingStore = database.createObjectStore(STORES.PENDING_SESSIONS, { keyPath: "id" });
-        pendingStore.createIndex("by-created", "createdAt");
-      }
-      if (!database.objectStoreNames.contains(STORES.CURRENT_SESSION)) {
-        database.createObjectStore(STORES.CURRENT_SESSION, { keyPath: "id" });
+      if (!database.objectStoreNames.contains(STORES.CURRENT_SESSION)) {
+        database.createObjectStore(STORES.CURRENT_SESSION, { keyPath: "id" });
       }
     };
   });
@@ -14344,6 +14386,29 @@ async function clearCurrentSessionBackup() {
     console.warn("[LogSpace] Failed to clear session backup:", error);
   }
 }
+async function clearCurrentSessionBackupFor(sessionId) {
+  if (!isIndexedDBAvailable()) return;
+  try {
+    const database = await initDB();
+    const transaction = database.transaction(STORES.CURRENT_SESSION, "readwrite");
+    const store = transaction.objectStore(STORES.CURRENT_SESSION);
+    const current = await new Promise((resolve2, reject) => {
+      const request = store.get("current");
+      request.onsuccess = () => resolve2(request.result || null);
+      request.onerror = () => reject(request.error);
+    });
+    if (!current || current.sessionId !== sessionId) {
+      return;
+    }
+    await new Promise((resolve2, reject) => {
+      const request = store.delete("current");
+      request.onsuccess = () => resolve2();
+      request.onerror = () => reject(request.error);
+    });
+  } catch (error) {
+    console.warn("[LogSpace] Failed to clear session backup:", error);
+  }
+}
 async function addPendingSession(payload) {
   if (!isIndexedDBAvailable()) return;
   try {
@@ -14447,14 +14512,13 @@ function closeDB() {
     dbInitPromise = null;
   }
 }
-const SDK_VERSION = "0.1.0";
+const SDK_VERSION = "1.1.0";
 let config = null;
 let session = null;
 let logs = [];
 let rrwebEvents = [];
 let initialized = false;
 let endReason = "manual";
-let sessionEndedByHardLimit = false;
 let sessionEndedByIdle = false;
 let rateLimiter = { count: 0, windowStart: 0 };
 let deduplication = { lastLogHash: null, lastLogCount: 0 };
@@ -14467,11 +14531,16 @@ let visibilityTimer = null;
 let lastMouseMoveTime = 0;
 let samplingTriggered = false;
 let samplingTriggerType = null;
+let samplingFirstTriggerTime = null;
 let samplingTriggerTime = null;
 let samplingEndTimer = null;
+let samplingTrimTimer = null;
 let continuingSessionId = null;
 let continuingSessionStartTime = null;
+let pendingIdentity = null;
+let currentIdentity = null;
 let recoveryTargetSessionId = null;
+const processedRecoverySessionIds = /* @__PURE__ */ new Set();
 const DEFAULT_CONFIG = {
   capture: {
     rrweb: true,
@@ -14488,7 +14557,7 @@ const DEFAULT_CONFIG = {
   },
   rrweb: {
     maskAllInputs: false,
-    checkoutEveryNth: 200,
+    checkoutEveryNth: 150,
     recordCanvas: false
   },
   privacy: {
@@ -14503,15 +14572,17 @@ const DEFAULT_CONFIG = {
     maxLogs: 1e4,
     maxSize: 10 * 1024 * 1024,
     // 10MB
-    maxDuration: 300,
-    // 5 minutes
-    idleTimeout: 30,
-    // 30 seconds
+    maxDuration: 1800,
+    // 30 minutes
+    idleTimeout: 120,
+    // 2 minutes
     navigateAwayTimeout: 120,
     // 2 minutes grace period
     rateLimit: 100,
     // 100 logs/second
-    deduplicate: true
+    deduplicate: true,
+    maxNetworkBodySize: 10
+    // 10KB (in KB, will be multiplied by 1024)
   },
   autoEnd: {
     continueOnRefresh: true,
@@ -14520,10 +14591,10 @@ const DEFAULT_CONFIG = {
   },
   sampling: {
     enabled: false,
-    bufferBefore: 15,
-    // 15 seconds before trigger
-    recordAfter: 15,
-    // 15 seconds after trigger
+    bufferBefore: 30,
+    // 30 seconds before trigger
+    recordAfter: 30,
+    // 30 seconds after trigger
     triggers: {
       onError: true,
       onConsoleError: true,
@@ -14559,6 +14630,87 @@ function generateSessionId() {
   const random = Math.random().toString(36).substring(2, 10);
   return `sdk_${timestamp}_${random}`;
 }
+const TAB_ID_KEY = "__logspace_tab_id";
+const SESSION_ID_KEY = "__logspace_session_id";
+let currentTabId = null;
+function generateTabId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `tab_${timestamp}_${random}`;
+}
+function getOrCreateTabId() {
+  if (currentTabId) return currentTabId;
+  if (typeof sessionStorage !== "undefined") {
+    const stored = sessionStorage.getItem(TAB_ID_KEY);
+    if (stored) {
+      currentTabId = stored;
+      return stored;
+    }
+  }
+  const created = generateTabId();
+  currentTabId = created;
+  try {
+    sessionStorage.setItem(TAB_ID_KEY, created);
+  } catch {
+  }
+  return created;
+}
+function setSessionContext(sessionId, tabId) {
+  try {
+    sessionStorage.setItem(SESSION_ID_KEY, sessionId);
+    sessionStorage.setItem(TAB_ID_KEY, tabId);
+  } catch {
+  }
+  try {
+    window.__logspace_session_id = sessionId;
+    window.__logspace_tab_id = tabId;
+  } catch {
+  }
+}
+function getSessionOrigin() {
+  if (typeof document === "undefined") return null;
+  const referrer = document.referrer || void 0;
+  let openerSessionId;
+  let openerTabId;
+  let openerUrl;
+  if (typeof window !== "undefined" && window.opener) {
+    try {
+      const opener = window.opener;
+      openerSessionId = opener.sessionStorage?.getItem(SESSION_ID_KEY) ?? opener.__logspace_session_id;
+      openerTabId = opener.sessionStorage?.getItem(TAB_ID_KEY) ?? opener.__logspace_tab_id;
+      openerUrl = opener.location?.href;
+    } catch {
+    }
+  }
+  if (!referrer && !openerSessionId && !openerTabId && !openerUrl) {
+    return null;
+  }
+  return {
+    referrer,
+    openerSessionId,
+    openerTabId,
+    openerUrl
+  };
+}
+function buildSessionMetadata(metadata) {
+  const origin = getSessionOrigin();
+  if (!origin && !metadata) return void 0;
+  if (!origin) return metadata;
+  const existingOrigin = metadata?.logspaceOrigin;
+  if (existingOrigin && typeof existingOrigin === "object" && !Array.isArray(existingOrigin)) {
+    return {
+      ...metadata,
+      logspaceOrigin: {
+        ...origin,
+        ...existingOrigin
+      }
+    };
+  }
+  return {
+    ...metadata || {},
+    logspaceOrigin: origin
+  };
+}
 function hashLog(log) {
   return `${log.type}:${JSON.stringify(log.data)}`;
 }
@@ -14571,13 +14723,13 @@ function checkRateLimit() {
     rateLimiter.count = 1;
     return true;
   }
-  if (rateLimiter.count >= config.limits.rateLimit) {
+  rateLimiter.count++;
+  if (rateLimiter.count > config.limits.rateLimit) {
     if (config.debug) {
       console.warn("[LogSpace] Rate limit exceeded, dropping log");
     }
     return false;
   }
-  rateLimiter.count++;
   return true;
 }
 function checkDeduplication(log) {
@@ -14610,9 +14762,6 @@ function checkLimits() {
 }
 function resetIdleTimer() {
   if (!config?.autoEnd.onIdle) return;
-  if (multiTabCoordinator.isActive() && !multiTabCoordinator.isLeaderTab()) {
-    return;
-  }
   if (idleTimer) {
     clearTimeout(idleTimer);
   }
@@ -14630,9 +14779,6 @@ function resetIdleTimer() {
 }
 function handleUserActivity() {
   if (!config || !initialized) return;
-  if (multiTabCoordinator.isActive() && !multiTabCoordinator.isLeaderTab()) {
-    return;
-  }
   if (sessionEndedByIdle && (!session || session.status === "stopped")) {
     if (config.debug) {
       console.log("[LogSpace] User activity detected - starting new session");
@@ -14665,33 +14811,54 @@ function removeActivityListeners() {
   window.removeEventListener("mousemove", handleMouseMove, { capture: true });
 }
 function triggerSampling(triggerType, triggerLog) {
-  if (!config?.sampling.enabled || samplingTriggered) return;
+  if (!config?.sampling.enabled) return;
+  if (unloadHandled || isNavigatingAway) {
+    if (config.debug) {
+      console.log(`[LogSpace] Ignoring sampling trigger during unload: ${triggerType}`);
+    }
+    return;
+  }
+  const isFirstTrigger = !samplingTriggered;
   samplingTriggered = true;
   samplingTriggerType = triggerType;
+  if (isFirstTrigger) {
+    samplingFirstTriggerTime = Date.now();
+  }
   samplingTriggerTime = Date.now();
+  stopSamplingTrimTimer();
   if (config.debug) {
-    console.log(`[LogSpace] Sampling triggered by: ${triggerType}`);
+    if (isFirstTrigger) {
+      console.log(`[LogSpace] Sampling triggered by: ${triggerType}`);
+    } else {
+      console.log(`[LogSpace] Sampling window extended by: ${triggerType}`);
+    }
+  }
+  if (isFirstTrigger) {
+    config.hooks.onSamplingTrigger?.(triggerType, triggerLog);
+  }
+  if (samplingEndTimer) {
+    clearTimeout(samplingEndTimer);
+    samplingEndTimer = null;
   }
-  config.hooks.onSamplingTrigger?.(triggerType, triggerLog);
   samplingEndTimer = setTimeout(() => {
     if (session?.status === "recording") {
       if (config?.debug) {
         console.log("[LogSpace] Sampling recordAfter period complete, ending session");
       }
       endReason = "samplingTriggered";
-      LogSpace.stopSession();
+      stopSessionInternal({ restartImmediately: true });
     }
   }, config.sampling.recordAfter * 1e3);
 }
 function checkSamplingTrigger(log) {
-  if (!config?.sampling.enabled || samplingTriggered) return;
+  if (!config?.sampling.enabled) return;
   if (config.sampling.triggers.onError && log.type === "error") {
     triggerSampling("error", log);
     return;
   }
   if (config.sampling.triggers.onConsoleError && log.type === "console") {
     const consoleData = log.data;
-    if (consoleData.level === "error") {
+    if (consoleData.level === "error" || consoleData.level === "assert") {
       triggerSampling("consoleError", log);
       return;
     }
@@ -14705,19 +14872,114 @@ function checkSamplingTrigger(log) {
   }
 }
 function trimLogsToSamplingWindow() {
-  if (!config?.sampling.enabled || !samplingTriggerTime || !session) return;
-  const bufferStartTime = samplingTriggerTime - config.sampling.bufferBefore * 1e3;
+  if (!config?.sampling.enabled || !samplingFirstTriggerTime || !samplingTriggerTime || !session) return;
+  const bufferStartTime = samplingFirstTriggerTime - config.sampling.bufferBefore * 1e3;
   const bufferEndTime = samplingTriggerTime + config.sampling.recordAfter * 1e3;
   logs = logs.filter((log) => {
     return log.timestamp >= bufferStartTime && log.timestamp <= bufferEndTime;
   });
-  rrwebEvents = rrwebEvents.filter((event) => {
+  const recentEvents = rrwebEvents.filter((event) => {
     return event.timestamp >= bufferStartTime && event.timestamp <= bufferEndTime;
   });
+  const hasFullSnapshot = recentEvents.some((event) => event.type === 2);
+  if (config.debug) {
+    console.log(
+      `[LogSpace] trimLogsToSamplingWindow - before: ${rrwebEvents.length} events, recentEvents: ${recentEvents.length}, hasFullSnapshot in recent: ${hasFullSnapshot}`
+    );
+    console.log(
+      `[LogSpace] trimLogsToSamplingWindow - rrweb types before: ${rrwebEvents.map((e) => e.type).join(",")}`
+    );
+  }
+  if (hasFullSnapshot) {
+    rrwebEvents = recentEvents;
+  } else {
+    const fullSnapshotsBeforeWindow = [];
+    for (let i = 0; i < rrwebEvents.length; i++) {
+      const event = rrwebEvents[i];
+      if (event && event.type === 2 && event.timestamp < bufferStartTime) {
+        fullSnapshotsBeforeWindow.push(event);
+      }
+    }
+    if (config.debug) {
+      console.log(
+        `[LogSpace] trimLogsToSamplingWindow - found ${fullSnapshotsBeforeWindow.length} snapshots before window`
+      );
+    }
+    if (fullSnapshotsBeforeWindow.length > 0) {
+      rrwebEvents = [...fullSnapshotsBeforeWindow, ...recentEvents];
+    } else {
+      rrwebEvents = recentEvents;
+    }
+  }
+  if (config.debug) {
+    console.log(
+      `[LogSpace] trimLogsToSamplingWindow - after: ${rrwebEvents.length} events, types: ${rrwebEvents.map((e) => e.type).join(",")}`
+    );
+  }
+  rebuildSessionStats();
   if (config.debug) {
     console.log(`[LogSpace] Trimmed to sampling window: ${logs.length} logs, ${rrwebEvents.length} rrweb events`);
   }
 }
+const SAMPLING_TRIM_INTERVAL = 5 * 1e3;
+function trimRollingBuffer() {
+  if (!config?.sampling.enabled || samplingTriggered || !session) return;
+  const now = Date.now();
+  const cutoffTime = now - config.sampling.bufferBefore * 1e3;
+  const prevLogCount = logs.length;
+  const prevRrwebCount = rrwebEvents.length;
+  logs = logs.filter((log) => log.timestamp >= cutoffTime);
+  const recentEvents = rrwebEvents.filter((event) => event.timestamp >= cutoffTime);
+  const hasFullSnapshot = recentEvents.some((event) => event.type === 2);
+  if (hasFullSnapshot) {
+    rrwebEvents = recentEvents;
+  } else {
+    let firstFullSnapshotIndex = -1;
+    const fullSnapshotIndices = [];
+    for (let i = 0; i < rrwebEvents.length; i++) {
+      const event = rrwebEvents[i];
+      if (event && event.type === 2 && event.timestamp < cutoffTime) {
+        if (firstFullSnapshotIndex === -1) {
+          firstFullSnapshotIndex = i;
+        }
+        fullSnapshotIndices.push(i);
+      }
+    }
+    if (firstFullSnapshotIndex >= 0) {
+      const snapshotsToKeep = fullSnapshotIndices.map((i) => rrwebEvents[i]).filter((e) => e !== void 0);
+      rrwebEvents = [...snapshotsToKeep, ...recentEvents];
+    } else {
+      rrwebEvents = recentEvents;
+    }
+  }
+  currentSize = logs.reduce((sum, log) => sum + JSON.stringify(log).length, 0);
+  rrwebSize = rrwebEvents.reduce((sum, event) => sum + JSON.stringify(event).length, 0);
+  rebuildSessionStats();
+  const trimmedLogs = prevLogCount - logs.length;
+  const trimmedRrweb = prevRrwebCount - rrwebEvents.length;
+  if (config.debug && (trimmedLogs > 0 || trimmedRrweb > 0)) {
+    console.log(
+      `[LogSpace] Rolling buffer trimmed: ${trimmedLogs} logs, ${trimmedRrweb} rrweb events (keeping last ${config.sampling.bufferBefore}s: ${logs.length} logs, ${rrwebEvents.length} rrweb events)`
+    );
+  }
+}
+function startSamplingTrimTimer() {
+  if (samplingTrimTimer || !config?.sampling.enabled) return;
+  samplingTrimTimer = setInterval(() => {
+    trimRollingBuffer();
+  }, SAMPLING_TRIM_INTERVAL);
+  if (config.debug) {
+    console.log(
+      `[LogSpace] Sampling rolling buffer started (trimming every ${SAMPLING_TRIM_INTERVAL / 1e3}s, keeping ${config.sampling.bufferBefore}s)`
+    );
+  }
+}
+function stopSamplingTrimTimer() {
+  if (samplingTrimTimer) {
+    clearInterval(samplingTrimTimer);
+    samplingTrimTimer = null;
+  }
+}
 const handleLog = (logData) => {
   if (!config || !session || session.status !== "recording") return;
   if (!checkRateLimit()) return;
@@ -14729,40 +14991,31 @@ const handleLog = (logData) => {
         console.log(`[LogSpace] Session auto-ended: ${limitReached}`);
       }
       endReason = limitReached;
-      sessionEndedByHardLimit = true;
       config.hooks.onLimitReached?.(limitReached);
-      LogSpace.stopSession();
+      stopSessionInternal({ restartImmediately: true });
     }
     return;
   }
-  const tabId = multiTabCoordinator.isActive() ? multiTabCoordinator.getTabId() : "single";
+  const tabId = getOrCreateTabId();
   const log = {
     id: `${logs.length + 1}`,
     timestamp: Date.now(),
     // Use absolute timestamp (consistent with rrweb events)
     tabId,
-    // Tab ID from multi-tab coordinator
     tabUrl: typeof window !== "undefined" ? window.location.href : "",
     type: logData.type,
     data: logData.data,
     severity: logData.severity
   };
-  if (multiTabCoordinator.isActive() && !multiTabCoordinator.isLeaderTab()) {
-    multiTabCoordinator.sendLog(log);
-    resetIdleTimer();
-    if (config.debug) {
-      console.log("[LogSpace] Captured (sent to leader):", log.type, log.data);
-    }
-    return;
-  }
-  logs.push(log);
-  currentSize += JSON.stringify(log).length;
-  updateStats(log);
+  const maskedLog = applyPrivacy(log, config.privacy);
+  logs.push(maskedLog);
+  currentSize += JSON.stringify(maskedLog).length;
+  updateStats(maskedLog);
   resetIdleTimer();
-  checkSamplingTrigger(log);
-  config.hooks.onAction?.(log, session);
+  checkSamplingTrigger(maskedLog);
+  config.hooks.onAction?.(maskedLog, session);
   if (config.debug) {
-    console.log("[LogSpace] Captured:", log.type, log.data);
+    console.log("[LogSpace] Captured:", maskedLog.type, maskedLog.data);
   }
 };
 function updateStats(log) {
@@ -14795,6 +15048,24 @@ function updateStats(log) {
       break;
   }
 }
+function rebuildSessionStats() {
+  if (!session) return;
+  const tabCount = session.stats.tabCount || 1;
+  session.stats = {
+    logCount: 0,
+    networkLogCount: 0,
+    consoleLogCount: 0,
+    errorCount: 0,
+    storageLogCount: 0,
+    interactionLogCount: 0,
+    performanceLogCount: 0,
+    annotationCount: 0,
+    tabCount
+  };
+  for (const log of logs) {
+    updateStats(log);
+  }
+}
 function installCaptures() {
   if (!config) return;
   const privacyWithSdkExclusions = { ...config.privacy };
@@ -14806,16 +15077,16 @@ function installCaptures() {
     consoleCapture.install(handleLog, config.privacy);
   }
   if (config.capture.network) {
-    networkCapture.install(handleLog, privacyWithSdkExclusions);
+    networkCapture.install(handleLog, privacyWithSdkExclusions, resetIdleTimer, config.limits);
   }
   if (config.capture.errors) {
     errorCapture.install(handleLog, config.privacy);
   }
   if (config.capture.websocket) {
-    websocketCapture.install(handleLog, config.privacy);
+    websocketCapture.install(handleLog, config.privacy, resetIdleTimer, config.limits);
   }
   if (config.capture.sse) {
-    sseCapture.install(handleLog, config.privacy);
+    sseCapture.install(handleLog, config.privacy, resetIdleTimer, config.limits);
   }
   if (config.capture.storage) {
     storageCapture.install(handleLog, config.privacy);
@@ -14846,12 +15117,10 @@ function uninstallCaptures() {
   spaNavigationCapture.uninstall();
 }
 let unloadHandled = false;
+let isNavigatingAway = false;
 const CHECKPOINT_INTERVAL = 15 * 1e3;
 async function saveCheckpoint() {
   if (!session || session.status !== "recording" || !isIndexedDBAvailable()) return;
-  if (multiTabCoordinator.isActive() && !multiTabCoordinator.isLeaderTab()) {
-    return;
-  }
   try {
     await saveSessionCheckpoint(session.id, logs, rrwebEvents, {
       startTime: session.startTime,
@@ -14886,6 +15155,37 @@ function stopCheckpointTimer() {
   }
 }
 const EMERGENCY_BACKUP_KEY = "__logspace_emergency_backup";
+const SAMPLING_STATE_KEY = "__logspace_sampling_state";
+function saveSamplingState(sessionId) {
+  if (!samplingTriggered) return;
+  try {
+    const state2 = {
+      triggered: samplingTriggered,
+      triggerType: samplingTriggerType,
+      firstTriggerTime: samplingFirstTriggerTime,
+      triggerTime: samplingTriggerTime,
+      sessionId
+    };
+    localStorage.setItem(SAMPLING_STATE_KEY, JSON.stringify(state2));
+  } catch (error) {
+  }
+}
+function getSamplingState() {
+  try {
+    const state2 = localStorage.getItem(SAMPLING_STATE_KEY);
+    if (state2) {
+      return JSON.parse(state2);
+    }
+  } catch (error) {
+  }
+  return null;
+}
+function clearSamplingState() {
+  try {
+    localStorage.removeItem(SAMPLING_STATE_KEY);
+  } catch (error) {
+  }
+}
 function saveEmergencyBackup(payload) {
   try {
     if (payload.logs.length === 0 && (!payload.rrwebEvents || payload.rrwebEvents.length < 3)) {
@@ -14915,16 +15215,9 @@ function clearEmergencyBackup() {
 function handleUnload() {
   if (unloadHandled) return;
   if (!config || !session || session.status !== "recording") return;
-  if (multiTabCoordinator.isActive() && !multiTabCoordinator.isLeaderTab()) {
-    if (config.debug) {
-      console.log("[LogSpace] Follower tab unloading - no session to save (data is with leader)");
-    }
-    return;
-  }
+  isNavigatingAway = true;
   unloadHandled = true;
   endReason = "unload";
-  const payload = buildPayload();
-  if (!payload) return;
   if (config.autoEnd.continueOnRefresh) {
     try {
       sessionStorage.setItem("logspace_continuing_session_id", session.id);
@@ -14935,6 +15228,13 @@ function handleUnload() {
       }
     } catch {
     }
+    if (samplingTriggered) {
+      saveSamplingState(session.id);
+    }
+  }
+  const payload = buildPayload();
+  if (!payload) {
+    return;
   }
   saveEmergencyBackup(payload);
   if (isIndexedDBAvailable()) {
@@ -14942,7 +15242,7 @@ function handleUnload() {
     });
   }
   if (config.debug) {
-    console.log("[LogSpace] Session saved for recovery on next visit");
+    console.log("[LogSpace] Session paused and saved for continuation");
   }
 }
 function handleVisibilityChange() {
@@ -14954,7 +15254,7 @@ function handleVisibilityChange() {
     }
     if (config.capture.rrweb) {
       addRRWebCustomEvent("tab-hidden", {
-        tabId: multiTabCoordinator.isActive() ? multiTabCoordinator.getTabId() : "main",
+        tabId: getOrCreateTabId(),
         timestamp: Date.now()
       });
     }
@@ -14963,14 +15263,8 @@ function handleVisibilityChange() {
     }
     visibilityTimer = setTimeout(() => {
       if (session?.status === "recording" && document.visibilityState === "hidden") {
-        if (multiTabCoordinator.isActive() && !multiTabCoordinator.isLeaderTab()) {
-          if (config?.debug) {
-            console.log("[LogSpace] Grace period expired, but follower tab - not ending session");
-          }
-          return;
-        }
         if (config?.debug) {
-          console.log("[LogSpace] Grace period expired, ending session");
+          console.log("[LogSpace] Grace period expired, saving session for continuation");
         }
         endReason = "navigateAway";
         handleUnload();
@@ -14984,8 +15278,20 @@ function handleVisibilityChange() {
       clearTimeout(visibilityTimer);
       visibilityTimer = null;
     }
+    if (isNavigatingAway || unloadHandled) {
+      const wasNavigating = isNavigatingAway;
+      const wasUnloadHandled = unloadHandled;
+      isNavigatingAway = false;
+      unloadHandled = false;
+      if (config?.debug) {
+        console.log("[LogSpace] Navigation flags reset - page is visible", {
+          wasNavigating,
+          wasUnloadHandled
+        });
+      }
+    }
     if (config?.capture.rrweb && session?.status === "recording") {
-      const tabId = multiTabCoordinator.isActive() ? multiTabCoordinator.getTabId() : "main";
+      const tabId = getOrCreateTabId();
       if (config.debug) {
         console.log("[LogSpace] Tab visible, forcing full rrweb snapshot for:", tabId);
       }
@@ -15005,8 +15311,13 @@ function buildPayload() {
   if (!session) return null;
   if (config?.sampling.enabled && !samplingTriggered) {
     if (config.debug) {
-      console.log("[LogSpace] Sampling enabled but not triggered - session not sent");
+      console.log("[LogSpace] Sampling enabled but not triggered - session discarded");
     }
+    let discardReason = "noTrigger";
+    if (endReason === "idle") discardReason = "idle";
+    else if (endReason === "maxDuration") discardReason = "maxDuration";
+    else if (endReason === "manual") discardReason = "manual";
+    config.hooks.onSessionDiscarded?.(session, discardReason);
     return null;
   }
   if (config?.sampling.enabled && samplingTriggered) {
@@ -15038,6 +15349,65 @@ function buildPayload() {
   }
   return payload;
 }
+async function stopSessionInternal(options) {
+  if (!session || session.status === "stopped") {
+    return;
+  }
+  const shouldRestart = options?.restartImmediately === true;
+  const endedSessionId = session.id;
+  session.status = "stopped";
+  session.endTime = Date.now();
+  continuingSessionId = null;
+  if (idleTimer) {
+    clearTimeout(idleTimer);
+    idleTimer = null;
+  }
+  if (durationTimer) {
+    clearTimeout(durationTimer);
+    durationTimer = null;
+  }
+  if (visibilityTimer) {
+    clearTimeout(visibilityTimer);
+    visibilityTimer = null;
+  }
+  stopCheckpointTimer();
+  stopSamplingTrimTimer();
+  if (config?.capture.rrweb) {
+    const events = stopRRWebRecording();
+    if (config.debug) {
+      console.log("[LogSpace] rrweb recording stopped, events:", events.length);
+    }
+  }
+  uninstallCaptures();
+  config?.hooks.onSessionEnd?.(session, logs);
+  if (config?.debug) {
+    console.log("[LogSpace] Session stopped:", session.id, {
+      duration: session.endTime - session.startTime,
+      logs: logs.length,
+      rrwebEvents: rrwebEvents.length,
+      reason: endReason
+    });
+  }
+  const payload = buildPayload();
+  if (shouldRestart) {
+    LogSpace.startSession();
+  }
+  if (!payload) {
+    await clearCurrentSessionBackupFor(endedSessionId);
+    clearEmergencyBackup();
+    clearSamplingState();
+    return;
+  }
+  try {
+    await sendPayload(payload);
+    await clearCurrentSessionBackupFor(endedSessionId);
+    clearEmergencyBackup();
+    clearSamplingState();
+  } catch (error) {
+    await addPendingSession(payload);
+    throw error;
+  }
+}
 async function compressPayload(data) {
   const encoder = new TextEncoder();
   const inputData = encoder.encode(data);
@@ -15064,9 +15434,7 @@ async function compressPayload(data) {
   }
   return new Blob([inputData], { type: "application/json" });
 }
-async function sendSession() {
-  const payload = buildPayload();
-  if (!payload) return;
+async function sendPayload(payload) {
   if (config?.dryRun) {
     console.log("[LogSpace] 🔶 DRY RUN - Session payload:", {
       id: payload.id,
@@ -15116,8 +15484,8 @@ async function sendSession() {
       // Use actual session start time for correct video seek calculation
       // SDK-specific fields for identify() and session info
       url: payload.url,
-      userId: session?.userId,
-      userTraits: session?.userTraits,
+      userId: payload.userId,
+      userTraits: payload.userTraits,
       duration: payload.duration,
       stats: payload.stats
     };
@@ -15207,6 +15575,27 @@ async function sendPayloadToServer(payload) {
     throw new Error(`HTTP ${response.status}: ${errorText}`);
   }
 }
+function serializeDedupValue(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function getLogDedupKey(log) {
+  if (log.id) {
+    return `id:${log.id}|ts:${log.timestamp}|type:${log.type}`;
+  }
+  return `ts:${log.timestamp}|type:${log.type}|data:${serializeDedupValue(log.data)}`;
+}
+function getEventDedupKey(event) {
+  const eventId = event.id ?? event.data?.id;
+  if (eventId !== void 0 && eventId !== null) {
+    return `id:${String(eventId)}|ts:${event.timestamp}|type:${event.type}`;
+  }
+  const data = event.data;
+  return `ts:${event.timestamp}|type:${event.type}|data:${serializeDedupValue(data)}`;
+}
 function mergeRecoveredData(recoveredLogs, recoveredEvents) {
   if (!session || session.status !== "recording") {
     if (config?.debug) {
@@ -15215,8 +15604,16 @@ function mergeRecoveredData(recoveredLogs, recoveredEvents) {
     return;
   }
   if (recoveredLogs.length > 0) {
-    const existingLogTimestamps = new Set(logs.map((l) => l.timestamp));
-    const newLogs = recoveredLogs.filter((l) => !existingLogTimestamps.has(l.timestamp));
+    const existingLogKeys = new Set(logs.map((l) => getLogDedupKey(l)));
+    const newLogs = [];
+    for (const log of recoveredLogs) {
+      const key = getLogDedupKey(log);
+      if (existingLogKeys.has(key)) {
+        continue;
+      }
+      existingLogKeys.add(key);
+      newLogs.push(log);
+    }
     if (newLogs.length > 0) {
       logs = [...newLogs, ...logs];
       for (const log of newLogs) {
@@ -15233,8 +15630,16 @@ function mergeRecoveredData(recoveredLogs, recoveredEvents) {
     }
   }
   if (recoveredEvents.length > 0) {
-    const existingEventTimestamps = new Set(rrwebEvents.map((e) => e.timestamp));
-    const newEvents = recoveredEvents.filter((e) => !existingEventTimestamps.has(e.timestamp));
+    const existingEventKeys = new Set(rrwebEvents.map((e) => getEventDedupKey(e)));
+    const newEvents = [];
+    for (const event of recoveredEvents) {
+      const key = getEventDedupKey(event);
+      if (existingEventKeys.has(key)) {
+        continue;
+      }
+      existingEventKeys.add(key);
+      newEvents.push(event);
+    }
     if (newEvents.length > 0) {
       rrwebEvents = [...newEvents, ...rrwebEvents];
       for (const event of newEvents) {
@@ -15255,11 +15660,17 @@ async function recoverPendingSessions() {
   try {
     const emergencyBackup = getEmergencyBackup();
     if (emergencyBackup) {
-      if (recoveryTargetSessionId && emergencyBackup.id === recoveryTargetSessionId) {
+      if (processedRecoverySessionIds.has(emergencyBackup.id)) {
+        if (config.debug) {
+          console.log("[LogSpace] Skipping already processed emergency backup:", emergencyBackup.id);
+        }
+        clearEmergencyBackup();
+      } else if (recoveryTargetSessionId && emergencyBackup.id === recoveryTargetSessionId) {
         if (config.debug) {
           console.log("[LogSpace] Merging emergency backup into continuing session:", emergencyBackup.id);
         }
         mergeRecoveredData(emergencyBackup.logs, emergencyBackup.rrwebEvents || []);
+        processedRecoverySessionIds.add(emergencyBackup.id);
         clearEmergencyBackup();
         await clearCurrentSessionBackup();
       } else {
@@ -15293,44 +15704,59 @@ async function recoverPendingSessions() {
     if (pendingSessions.length === 0) {
       const backup = await getCurrentSessionBackup();
       if (backup && backup.logs.length > 0) {
-        if (config.debug) {
-          console.log("[LogSpace] Recovering crashed session:", backup.sessionId);
-        }
-        const recoveredPayload = {
-          id: backup.sessionId,
-          startTime: backup.startTime,
-          endTime: backup.lastCheckpoint,
-          duration: backup.lastCheckpoint - backup.startTime,
-          url: backup.url,
-          title: backup.title,
-          userId: backup.userId,
-          userTraits: backup.userTraits,
-          metadata: backup.metadata,
-          logs: backup.logs,
-          stats: {
-            logCount: backup.logs.length,
-            networkLogCount: backup.logs.filter((l) => l.type === "network").length,
-            consoleLogCount: backup.logs.filter((l) => l.type === "console").length,
-            errorCount: backup.logs.filter((l) => l.type === "error").length,
-            storageLogCount: backup.logs.filter((l) => l.type === "storage").length,
-            interactionLogCount: backup.logs.filter((l) => l.type === "interaction").length,
-            performanceLogCount: backup.logs.filter((l) => l.type === "performance").length,
-            annotationCount: backup.logs.filter((l) => l.type === "annotation").length,
-            tabCount: 1
-            // SDK always has single tab
-          },
-          endReason: "crash",
-          recordingType: "rrweb",
-          rrwebEvents: backup.rrwebEvents,
-          sdkVersion: SDK_VERSION
-        };
-        pendingSessions.push({
-          id: backup.sessionId,
-          data: recoveredPayload,
-          createdAt: backup.lastCheckpoint,
-          retryCount: 0
-        });
-        await clearCurrentSessionBackup();
+        if (recoveryTargetSessionId && backup.sessionId === recoveryTargetSessionId) {
+          if (config.debug) {
+            console.log("[LogSpace] Merging checkpoint backup into continuing session:", backup.sessionId);
+          }
+          mergeRecoveredData(backup.logs, backup.rrwebEvents || []);
+          processedRecoverySessionIds.add(backup.sessionId);
+          await clearCurrentSessionBackup();
+        } else if (processedRecoverySessionIds.has(backup.sessionId)) {
+          if (config.debug) {
+            console.log("[LogSpace] Skipping already processed backup:", backup.sessionId);
+          }
+          await clearCurrentSessionBackup();
+        } else {
+          if (config.debug) {
+            console.log("[LogSpace] Recovering crashed session:", backup.sessionId);
+          }
+          const recoveredPayload = {
+            id: backup.sessionId,
+            startTime: backup.startTime,
+            endTime: backup.lastCheckpoint,
+            duration: backup.lastCheckpoint - backup.startTime,
+            url: backup.url,
+            title: backup.title,
+            userId: backup.userId,
+            userTraits: backup.userTraits,
+            metadata: backup.metadata,
+            logs: backup.logs,
+            stats: {
+              logCount: backup.logs.length,
+              networkLogCount: backup.logs.filter((l) => l.type === "network").length,
+              consoleLogCount: backup.logs.filter((l) => l.type === "console").length,
+              errorCount: backup.logs.filter((l) => l.type === "error").length,
+              storageLogCount: backup.logs.filter((l) => l.type === "storage").length,
+              interactionLogCount: backup.logs.filter((l) => l.type === "interaction").length,
+              performanceLogCount: backup.logs.filter((l) => l.type === "performance").length,
+              annotationCount: backup.logs.filter((l) => l.type === "annotation").length,
+              tabCount: 1
+              // SDK always has single tab
+            },
+            endReason: "crash",
+            recordingType: "rrweb",
+            rrwebEvents: backup.rrwebEvents,
+            sdkVersion: SDK_VERSION
+          };
+          pendingSessions.push({
+            id: backup.sessionId,
+            data: recoveredPayload,
+            createdAt: backup.lastCheckpoint,
+            retryCount: 0
+          });
+          await addPendingSession(recoveredPayload);
+          await clearCurrentSessionBackup();
+        }
       }
     }
     if (pendingSessions.length === 0) return;
@@ -15338,16 +15764,25 @@ async function recoverPendingSessions() {
       console.log(`[LogSpace] Recovering ${pendingSessions.length} pending session(s)`);
     }
     for (const stored of pendingSessions) {
+      if (processedRecoverySessionIds.has(stored.id)) {
+        if (config.debug) {
+          console.log("[LogSpace] Skipping already processed pending session:", stored.id);
+        }
+        await removePendingSession(stored.id);
+        continue;
+      }
       if (recoveryTargetSessionId && stored.id === recoveryTargetSessionId) {
         if (config.debug) {
           console.log("[LogSpace] Merging pending session into continuing session:", stored.id);
         }
         mergeRecoveredData(stored.data.logs, stored.data.rrwebEvents || []);
+        processedRecoverySessionIds.add(stored.id);
         await removePendingSession(stored.id);
         continue;
       }
       try {
         await sendPayloadToServer(stored.data);
+        processedRecoverySessionIds.add(stored.id);
         await removePendingSession(stored.id);
         if (config.debug) {
           console.log("[LogSpace] Recovered session sent:", stored.id);
@@ -15370,11 +15805,11 @@ async function recoverPendingSessions() {
 const LogSpace = {
   /**
    * Initialize the SDK
+   * @throws Error if SDK is already initialized
    */
   init(userConfig) {
     if (initialized) {
-      console.warn("[LogSpace] SDK already initialized");
-      return;
+      throw new Error("[LogSpace] SDK already initialized. Call destroy() first if you need to reinitialize.");
     }
     if (typeof window === "undefined") {
       console.warn("[LogSpace] SDK requires browser environment");
@@ -15387,54 +15822,9 @@ const LogSpace = {
         version: SDK_VERSION,
         serverUrl: config.serverUrl,
         limits: config.limits,
-        persistence: isIndexedDBAvailable() ? "enabled" : "disabled",
-        multiTab: multiTabCoordinator.isSupported() ? "enabled" : "disabled"
+        persistence: isIndexedDBAvailable() ? "enabled" : "disabled"
       });
     }
-    if (multiTabCoordinator.isSupported()) {
-      multiTabCoordinator.init(
-        {
-          onBecomeLeader: (sessionId, isNewSession) => {
-            if (config?.debug) {
-              console.log("[LogSpace] This tab is now the leader", { sessionId, isNewSession });
-            }
-            if (!isNewSession) {
-              continuingSessionId = sessionId;
-            }
-            if (!session) {
-              LogSpace.startSession();
-            }
-          },
-          onBecomeFollower: (sessionId) => {
-            if (config?.debug) {
-              console.log("[LogSpace] This tab is now a follower", { sessionId });
-            }
-            if (!session) {
-              LogSpace.startSession();
-            }
-          },
-          onReceiveLog: (log) => {
-            if (session?.status === "recording") {
-              logs.push(log);
-              currentSize += JSON.stringify(log).length;
-              updateStats(log);
-            }
-          },
-          onReceiveRRWebEvent: (event) => {
-            if (session?.status === "recording") {
-              rrwebEvents.push(event);
-              rrwebSize += JSON.stringify(event).length;
-            }
-          },
-          onLeaderChanged: (newLeaderTabId) => {
-            if (config?.debug) {
-              console.log("[LogSpace] Leader changed to:", newLeaderTabId);
-            }
-          }
-        },
-        config.debug
-      );
-    }
     if (config.autoEnd.continueOnRefresh) {
       try {
         const savedSessionId = sessionStorage.getItem("logspace_continuing_session_id");
@@ -15481,9 +15871,8 @@ const LogSpace = {
       installActivityListeners();
     }
     unloadHandled = false;
-    if (!multiTabCoordinator.isActive()) {
-      this.startSession();
-    }
+    isNavigatingAway = false;
+    this.startSession();
     recoverPendingSessions().catch(() => {
     });
   },
@@ -15499,20 +15888,16 @@ const LogSpace = {
       console.warn("[LogSpace] Session already recording");
       return;
     }
-    if (sessionEndedByHardLimit) {
-      if (config.debug) {
-        console.log("[LogSpace] Session not restarted - previous session ended by hard limit");
-      }
-      return;
-    }
     sessionEndedByIdle = false;
     samplingTriggered = false;
     samplingTriggerType = null;
+    samplingFirstTriggerTime = null;
     samplingTriggerTime = null;
     if (samplingEndTimer) {
       clearTimeout(samplingEndTimer);
       samplingEndTimer = null;
     }
+    stopSamplingTrimTimer();
     logs = [];
     rrwebEvents = [];
     currentSize = 0;
@@ -15522,28 +15907,44 @@ const LogSpace = {
     endReason = "manual";
     let sessionId;
     let sessionStartTime;
-    if (multiTabCoordinator.isActive() && multiTabCoordinator.getSessionId()) {
-      sessionId = multiTabCoordinator.getSessionId();
-      sessionStartTime = Date.now();
-    } else if (continuingSessionId) {
+    let restoredSamplingState = false;
+    if (continuingSessionId) {
       sessionId = continuingSessionId;
       sessionStartTime = continuingSessionStartTime || Date.now();
       if (config.debug) {
         console.log("[LogSpace] Using continuing session ID:", sessionId, "with original startTime:", sessionStartTime);
       }
+      const savedSamplingState = getSamplingState();
+      if (savedSamplingState && savedSamplingState.sessionId === sessionId && savedSamplingState.triggered) {
+        samplingTriggered = savedSamplingState.triggered;
+        samplingTriggerType = savedSamplingState.triggerType;
+        samplingFirstTriggerTime = savedSamplingState.firstTriggerTime;
+        samplingTriggerTime = savedSamplingState.triggerTime;
+        restoredSamplingState = true;
+        if (config.debug) {
+          console.log("[LogSpace] Restored sampling state from before refresh:", savedSamplingState.triggerType);
+        }
+      }
+      clearSamplingState();
       continuingSessionId = null;
       continuingSessionStartTime = null;
     } else {
       sessionId = generateSessionId();
       sessionStartTime = Date.now();
     }
+    const identityToApply = pendingIdentity || currentIdentity;
+    const tabId = getOrCreateTabId();
+    const sessionMetadata = buildSessionMetadata(metadata);
     session = {
       id: sessionId,
+      tabId,
       startTime: sessionStartTime,
       status: "recording",
       url: window.location.href,
       title: document.title,
-      metadata,
+      metadata: sessionMetadata,
+      userId: identityToApply?.userId,
+      userTraits: identityToApply?.traits,
       stats: {
         logCount: 0,
         networkLogCount: 0,
@@ -15553,11 +15954,10 @@ const LogSpace = {
         interactionLogCount: 0,
         performanceLogCount: 0,
         annotationCount: 0,
-        tabCount: multiTabCoordinator.isActive() ? 0 : 1
-        // Will be updated by multi-tab coordinator
+        tabCount: 1
       }
     };
-    const tabId = multiTabCoordinator.isActive() ? multiTabCoordinator.getTabId() : void 0;
+    setSessionContext(sessionId, tabId);
     if (config.capture.rrweb) {
       const rrwebStarted = startRRWebRecording(
         {
@@ -15570,23 +15970,17 @@ const LogSpace = {
         },
         (event) => {
           if (!session || session.status !== "recording") return;
-          if (multiTabCoordinator.isActive() && !multiTabCoordinator.isLeaderTab()) {
-            multiTabCoordinator.sendRRWebEvent(event);
-            resetIdleTimer();
-            return;
-          }
           const eventSize = JSON.stringify(event).length;
           rrwebSize += eventSize;
           const totalSize = currentSize + rrwebSize;
           if (config && totalSize >= config.limits.maxSize) {
-            if (config.autoEnd.onLimitReached && !sessionEndedByHardLimit) {
-              sessionEndedByHardLimit = true;
+            if (config.autoEnd.onLimitReached) {
               if (config.debug) {
                 console.log("[LogSpace] Session auto-ended: maxSize (rrweb)");
               }
               endReason = "maxSize";
               config.hooks.onLimitReached?.("maxSize");
-              LogSpace.stopSession();
+              stopSessionInternal({ restartImmediately: true });
             }
             return;
           }
@@ -15607,13 +16001,47 @@ const LogSpace = {
           }
           endReason = "maxDuration";
           config?.hooks.onLimitReached?.("maxDuration");
-          this.stopSession();
+          stopSessionInternal({ restartImmediately: true });
         }
       }, config.limits.maxDuration * 1e3);
     }
     resetIdleTimer();
     installCaptures();
     startCheckpointTimer();
+    if (config.sampling.enabled && !restoredSamplingState) {
+      startSamplingTrimTimer();
+    } else if (config.sampling.enabled && restoredSamplingState && samplingTriggerTime) {
+      const elapsed = Date.now() - samplingTriggerTime;
+      const remainingTime = Math.max(0, config.sampling.recordAfter * 1e3 - elapsed);
+      if (config.debug) {
+        console.log(`[LogSpace] Sampling was triggered before refresh, ${remainingTime}ms remaining in recordAfter`);
+      }
+      if (remainingTime > 0) {
+        samplingEndTimer = setTimeout(() => {
+          if (session?.status === "recording") {
+            if (config?.debug) {
+              console.log("[LogSpace] Sampling recordAfter period complete, ending session");
+            }
+            endReason = "samplingTriggered";
+            stopSessionInternal({ restartImmediately: true });
+          }
+        }, remainingTime);
+      } else {
+        if (config.debug) {
+          console.log("[LogSpace] Sampling recordAfter period already elapsed, ending session");
+        }
+        endReason = "samplingTriggered";
+        stopSessionInternal({ restartImmediately: true });
+      }
+    }
+    if (session && identityToApply) {
+      if (pendingIdentity && config.debug) {
+        console.log("[LogSpace] Applied pending user identity:", identityToApply.userId);
+      }
+    }
+    if (pendingIdentity) {
+      pendingIdentity = null;
+    }
     if (session) {
       config.hooks.onSessionStart?.(session);
       if (config.debug) {
@@ -15625,68 +16053,23 @@ const LogSpace = {
    * Stop recording and send session to server
    */
   async stopSession() {
-    if (!session || session.status === "stopped") {
-      return;
-    }
-    session.status = "stopped";
-    session.endTime = Date.now();
-    continuingSessionId = null;
-    if (idleTimer) {
-      clearTimeout(idleTimer);
-      idleTimer = null;
-    }
-    if (durationTimer) {
-      clearTimeout(durationTimer);
-      durationTimer = null;
-    }
-    if (visibilityTimer) {
-      clearTimeout(visibilityTimer);
-      visibilityTimer = null;
-    }
-    stopCheckpointTimer();
-    if (config?.capture.rrweb) {
-      const events = stopRRWebRecording();
-      if (config.debug) {
-        console.log("[LogSpace] rrweb recording stopped, events:", events.length);
-      }
-    }
-    uninstallCaptures();
-    config?.hooks.onSessionEnd?.(session, logs);
-    if (config?.debug) {
-      console.log("[LogSpace] Session stopped:", session.id, {
-        duration: session.endTime - session.startTime,
-        logs: logs.length,
-        rrwebEvents: rrwebEvents.length,
-        reason: endReason
-      });
-    }
-    if (!multiTabCoordinator.isActive() || multiTabCoordinator.isLeaderTab()) {
-      try {
-        await sendSession();
-        await clearCurrentSessionBackup();
-        clearEmergencyBackup();
-        if (multiTabCoordinator.isActive()) {
-          multiTabCoordinator.endSession();
-        }
-      } catch (error) {
-        const payload = buildPayload();
-        if (payload) {
-          await addPendingSession(payload);
-        }
-        throw error;
-      }
-    }
+    await stopSessionInternal();
   },
   /**
    * Identify user
+   * If called before session starts, the identity will be queued and applied when session starts
    */
   identify(userId, traits) {
-    if (!session) return;
+    currentIdentity = { userId, traits };
+    if (!session) {
+      pendingIdentity = { userId, traits };
+      if (config?.debug) {
+        console.log("[LogSpace] User identity queued (session not started yet):", userId);
+      }
+      return;
+    }
     session.userId = userId;
     session.userTraits = traits;
-    if (multiTabCoordinator.isActive()) {
-      multiTabCoordinator.updateSessionUser(userId, traits);
-    }
     if (config?.debug) {
       console.log("[LogSpace] User identified:", userId);
     }
@@ -15699,7 +16082,7 @@ const LogSpace = {
       type: "annotation",
       data: {
         annotationType: "event",
-        event,
+        eventName: event,
         properties
       }
     });
@@ -15780,6 +16163,51 @@ const LogSpace = {
   getRRWebEvents() {
     return [...rrwebEvents];
   },
+  /**
+   * Get current configuration (read-only)
+   * Returns the full NormalizedConfig plus convenience top-level fields
+   * that match the setConfig() interface for easy verification
+   */
+  getConfig() {
+    if (!config) return null;
+    return {
+      ...config,
+      // Expose convenience top-level fields that match setConfig() interface
+      rateLimit: config.limits.rateLimit,
+      maxLogs: config.limits.maxLogs,
+      maxSize: config.limits.maxSize,
+      idleTimeout: config.limits.idleTimeout
+    };
+  },
+  /**
+   * Update configuration at runtime
+   * Only certain settings can be changed after initialization
+   */
+  setConfig(updates) {
+    if (!config) {
+      console.warn("[LogSpace] SDK not initialized, cannot update config");
+      return;
+    }
+    if (updates.rateLimit !== void 0) {
+      config.limits.rateLimit = updates.rateLimit;
+    }
+    if (updates.maxLogs !== void 0) {
+      config.limits.maxLogs = updates.maxLogs;
+    }
+    if (updates.maxSize !== void 0) {
+      config.limits.maxSize = updates.maxSize;
+    }
+    if (updates.idleTimeout !== void 0) {
+      config.limits.idleTimeout = updates.idleTimeout;
+      resetIdleTimer();
+    }
+    if (updates.debug !== void 0) {
+      config.debug = updates.debug;
+    }
+    if (config.debug) {
+      console.log("[LogSpace] Config updated:", updates);
+    }
+  },
   /**
    * Destroy SDK
    */
@@ -15802,9 +16230,7 @@ const LogSpace = {
       visibilityTimer = null;
     }
     stopCheckpointTimer();
-    if (multiTabCoordinator.isActive()) {
-      multiTabCoordinator.cleanup();
-    }
+    stopSamplingTrimTimer();
     if (config?.capture.rrweb) {
       stopRRWebRecording();
     }
@@ -15823,14 +16249,16 @@ const LogSpace = {
     rrwebEvents = [];
     currentSize = 0;
     rrwebSize = 0;
-    sessionEndedByHardLimit = false;
     sessionEndedByIdle = false;
     samplingTriggered = false;
     samplingTriggerType = null;
+    samplingFirstTriggerTime = null;
     samplingTriggerTime = null;
     recoveryTargetSessionId = null;
     unloadHandled = false;
+    isNavigatingAway = false;
     lastMouseMoveTime = 0;
+    currentTabId = null;
     initialized = false;
     if (wasDebug) {
       console.log("[LogSpace] SDK destroyed");