@infinitewatch/web-core 0.0.0

package/dist/index.js

@@ -0,0 +1,1681 @@
+// src/core.ts
+var isRecord = (value) => typeof value === "object" && value !== null;
+var getMutationData = (event) => {
+  if (!event || event.type !== 3) return null;
+  const data = event.data;
+  if (!data || data.source !== 0) return null;
+  return data;
+};
+var LIB_VERSION = "v43.1";
+var EXCLUDED_ORGANIZATIONS = {
+  NORTHIUS: "68f7bc5a815d853ecb2ce914"
+};
+var EXCLUDED_ORG_IDS = new Set(Object.values(EXCLUDED_ORGANIZATIONS));
+var DEFAULT_CONFIG = {
+  baseUrl: "https://ingest.infinitewatch.ai",
+  endpoint: "https://ingest.infinitewatch.ai/v1/ingest",
+  endpointConfig: "https://ingest.infinitewatch.ai/v1/ingest/config",
+  sessionId: null,
+  userId: null,
+  organizationId: null,
+  debug: false,
+  defaultSamplingPercent: 100,
+  maskAllInputs: true,
+  maskInputOptions: {
+    password: true,
+    email: true,
+    text: true,
+    tel: true,
+    url: true,
+    textarea: true,
+    select: true,
+    checkbox: true,
+    radio: true,
+    file: true
+  },
+  blockClass: "",
+  blockSelector: "",
+  maskTextSelector: "",
+  maskTextClass: "",
+  recordIframe: false,
+  recordCanvas: false,
+  recordCrossOriginIframes: false,
+  sessionStorageKey: "iw_session",
+  autoResumeSession: true,
+  batchSize: 200,
+  flushInterval: 1e4,
+  sessionTimeout: 30 * 60 * 1e3,
+  sessionHeartbeatInterval: null,
+  refresh: false,
+  inlineStylesheet: false,
+  generateInsights: false,
+  blackList: ["yui_"]
+};
+var BYTES_IN_KILOBYTE = 1024;
+var URL_PARAMS = {
+  VERSION: "v",
+  REQUEST_TYPE: "t",
+  KEEPALIVE: "k",
+  SIZE: "s",
+  COMPRESSION: "c",
+  SESSION_ID: "i"
+};
+var getWindow = () => {
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof globalThis !== "undefined" && "window" in globalThis) {
+    return globalThis.window;
+  }
+  const doc = typeof document !== "undefined" ? document : typeof globalThis !== "undefined" && "document" in globalThis ? (
+    // biome-ignore lint/suspicious/noExplicitAny: globalThis typing for non-standard environments
+    globalThis.document
+  ) : void 0;
+  return doc?.defaultView ?? void 0;
+};
+var getDocument = () => {
+  if (typeof document !== "undefined") {
+    return document;
+  }
+  if (typeof globalThis !== "undefined" && "document" in globalThis) {
+    return globalThis.document;
+  }
+  return void 0;
+};
+var isBrowser = () => !!(getWindow() && getDocument());
+var now = () => Date.now();
+var isOrganizationExcluded = (orgId) => {
+  return !!orgId && EXCLUDED_ORG_IDS.has(orgId);
+};
+var createWebCore = () => {
+  let config = { ...DEFAULT_CONFIG };
+  let isInitialized = false;
+  let eventBuffer = [];
+  let flushTimer = null;
+  let stopRecording = null;
+  let sessionId = null;
+  let userId = null;
+  let externalId = null;
+  let organizationId = null;
+  let sessionHeartbeatTimer = null;
+  let sessionExpiryTimer = null;
+  let isSessionActive = false;
+  let sessionStartTime = null;
+  let isSampledIn = true;
+  let hardStop = false;
+  let contractStatus = null;
+  let quotaStatus = null;
+  let lastRecordedUrl = "";
+  let urlChangeCleanup = null;
+  const log = (message, ...args) => {
+    if (config.debug) {
+      console.log(
+        "[InfiniteWatch]",
+        (/* @__PURE__ */ new Date()).toISOString(),
+        message,
+        ...args
+      );
+    }
+  };
+  const error = (message, ...args) => {
+    if (config.debug) {
+      console.error(
+        "[InfiniteWatch]",
+        (/* @__PURE__ */ new Date()).toISOString(),
+        "ERROR:",
+        message,
+        ...args
+      );
+      if (args.length > 0 && args[0] instanceof Error) {
+        console.error("[InfiniteWatch] Stack trace:", args[0].stack);
+      }
+    }
+  };
+  const generateSessionId = () => {
+    const nextId = `session_${now()}_${Math.random().toString(36).slice(2, 11)}`;
+    log("Generated new session ID:", nextId);
+    return nextId;
+  };
+  const generateUserId = () => {
+    const nextId = `user_${Math.random().toString(36).slice(2, 11)}`;
+    log("Generated new user ID:", nextId);
+    return nextId;
+  };
+  const getSamplingPercentForOrg = (orgId) => {
+    if (!orgId) {
+      return typeof config.defaultSamplingPercent === "number" ? config.defaultSamplingPercent : 50;
+    }
+    const base = typeof config.defaultSamplingPercent === "number" ? config.defaultSamplingPercent : 50;
+    return Math.max(0, Math.min(100, base));
+  };
+  const hashStringToPercent = (value) => {
+    let hash = 5381;
+    const input = String(value);
+    for (let i = 0; i < input.length; i += 1) {
+      hash = (hash << 5) + hash + input.charCodeAt(i);
+      hash |= 0;
+    }
+    return Math.abs(hash) % 100;
+  };
+  const shouldSample = (orgId, sessId) => {
+    const percent = getSamplingPercentForOrg(orgId);
+    const bucket = hashStringToPercent(sessId || "");
+    return bucket < percent;
+  };
+  const compressGzip = async (data) => {
+    if (typeof CompressionStream !== "undefined") {
+      try {
+        const originalSize = new Blob([data]).size;
+        const stream = new Blob([data]).stream();
+        const compressedStream = stream.pipeThrough(
+          new CompressionStream("gzip")
+        );
+        const compressedBlob = await new Response(compressedStream).blob();
+        return { body: compressedBlob, compressed: true, originalSize };
+      } catch (err) {
+        log("Compression failed, sending uncompressed:", err);
+        const fallbackBlob2 = new Blob([data]);
+        return {
+          body: fallbackBlob2,
+          compressed: false,
+          originalSize: fallbackBlob2.size
+        };
+      }
+    }
+    log("CompressionStream not available, sending uncompressed");
+    const fallbackBlob = new Blob([data]);
+    return {
+      body: fallbackBlob,
+      compressed: false,
+      originalSize: fallbackBlob.size
+    };
+  };
+  const getCookieDomain = () => {
+    const win = getWindow();
+    if (!win) return "";
+    const hostname = win.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1" || /^\d+\.\d+\.\d+\.\d+$/.test(hostname)) {
+      return "";
+    }
+    const parts = hostname.split(".");
+    if (parts.length >= 2) {
+      return `.${parts.slice(-2).join(".")}`;
+    }
+    return hostname;
+  };
+  const getCookieSecurityAttrs = () => {
+    return "; Secure; SameSite=None";
+  };
+  const setCookie = (name, value, days = 365) => {
+    const doc = getDocument();
+    if (!doc) return;
+    const expires = /* @__PURE__ */ new Date();
+    expires.setTime(expires.getTime() + days * 24 * 60 * 60 * 1e3);
+    const encodedValue = encodeURIComponent(value);
+    const domain = getCookieDomain();
+    const domainAttr = domain ? `; Domain=${domain}` : "";
+    const securityAttrs = getCookieSecurityAttrs();
+    const cookieBase = `${name}=${encodedValue}`;
+    const cookieWithAttrs = `${cookieBase}; expires=${expires.toUTCString()}; Path=/${domainAttr}${securityAttrs}`;
+    doc.cookie = cookieWithAttrs;
+    if (!doc.cookie.includes(`${name}=`)) {
+      doc.cookie = cookieBase;
+    }
+  };
+  const getCookie = (name) => {
+    const doc = getDocument();
+    if (!doc) return null;
+    const nameEQ = `${name}=`;
+    const ca = doc.cookie.split(";");
+    for (let i = 0; i < ca.length; i += 1) {
+      let c = ca[i] ?? "";
+      while (c.charAt(0) === " ") c = c.substring(1, c.length);
+      if (c.indexOf(nameEQ) === 0) {
+        return decodeURIComponent(c.substring(nameEQ.length, c.length));
+      }
+    }
+    return null;
+  };
+  const deleteCookie = (name) => {
+    const doc = getDocument();
+    if (!doc) return;
+    const domain = getCookieDomain();
+    const domainAttr = domain ? `; Domain=${domain}` : "";
+    const securityAttrs = getCookieSecurityAttrs();
+    doc.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Path=/${domainAttr}${securityAttrs}`;
+  };
+  const saveSessionToStorage = () => {
+    const storageKey = config.sessionStorageKey || "iw_session";
+    if (!storageKey) {
+      log("No session storage key configured, skipping save");
+      return;
+    }
+    const sessionData = {
+      sessionId,
+      userId,
+      organizationId,
+      lastActivity: now(),
+      sessionStartTime,
+      isActive: isSessionActive,
+      config: {
+        endpoint: config.endpoint,
+        sessionTimeout: config.sessionTimeout
+      }
+    };
+    if (externalId) {
+      sessionData.externalId = externalId;
+    }
+    try {
+      setCookie(storageKey, JSON.stringify(sessionData), 730);
+      log("Saved session to storage with user identity");
+    } catch (err) {
+      error("Failed to save session to storage:", err);
+    }
+  };
+  const clearSessionFromStorage = () => {
+    const storageKey = config.sessionStorageKey || "iw_session";
+    if (!storageKey) {
+      log("No session storage key configured, skipping clear");
+      return;
+    }
+    try {
+      deleteCookie(storageKey);
+    } catch (err) {
+      error("Failed to clear session from storage:", err);
+    }
+  };
+  const loadSessionFromStorage = () => {
+    const storageKey = config.sessionStorageKey || "iw_session";
+    if (!storageKey) {
+      log("No session storage key configured, skipping load");
+      return null;
+    }
+    try {
+      const sessionData = getCookie(storageKey);
+      if (!sessionData) {
+        log("No session data found in storage");
+        return null;
+      }
+      const parsed = JSON.parse(sessionData);
+      const timeSinceLastActivity = now() - parsed.lastActivity;
+      const totalSessionDuration = parsed.sessionStartTime ? now() - parsed.sessionStartTime : 0;
+      if (timeSinceLastActivity > config.sessionTimeout || totalSessionDuration > config.sessionTimeout) {
+        clearSessionFromStorage();
+        return null;
+      }
+      log("Session loaded from storage successfully:", parsed);
+      return parsed;
+    } catch (err) {
+      error("Failed to load session from storage:", err);
+      clearSessionFromStorage();
+      return null;
+    }
+  };
+  const getOrCreateUserId = () => {
+    const existingSession = loadSessionFromStorage();
+    if (existingSession?.userId) {
+      log("Using existing userId from cookie:", existingSession.userId);
+      return existingSession.userId;
+    }
+    const newUserId = generateUserId();
+    log("Generated new userId:", newUserId);
+    return newUserId;
+  };
+  const updateSessionActivity = () => {
+    if (isSessionActive) {
+      saveSessionToStorage();
+      if (config.refresh) {
+        resetSessionExpiryTimer();
+      }
+    }
+  };
+  const startSessionHeartbeat = () => {
+    if (sessionHeartbeatTimer) {
+      clearInterval(sessionHeartbeatTimer);
+    }
+    if (config.sessionHeartbeatInterval) {
+      sessionHeartbeatTimer = setInterval(() => {
+        if (isSessionActive) {
+          if (config.refresh) {
+            updateSessionActivity();
+          } else {
+            saveSessionToStorage();
+          }
+        }
+      }, config.sessionHeartbeatInterval);
+    }
+  };
+  const stopSessionHeartbeat = () => {
+    if (sessionHeartbeatTimer) {
+      clearInterval(sessionHeartbeatTimer);
+      sessionHeartbeatTimer = null;
+    } else {
+      log("No heartbeat timer to stop");
+    }
+  };
+  const startSessionExpiryTimer = () => {
+    if (sessionExpiryTimer) {
+      clearTimeout(sessionExpiryTimer);
+    }
+    let timeoutDuration = config.sessionTimeout;
+    if (sessionStartTime) {
+      const elapsed = now() - sessionStartTime;
+      const remaining = config.sessionTimeout - elapsed;
+      if (remaining <= 0) {
+        clearSessionFromStorage();
+        sessionId = generateSessionId();
+        sessionStartTime = now();
+        timeoutDuration = config.sessionTimeout;
+      } else {
+        timeoutDuration = remaining;
+      }
+    }
+    sessionExpiryTimer = setTimeout(() => {
+      stopRecordingSession();
+    }, timeoutDuration);
+  };
+  const resetSessionExpiryTimer = () => {
+    if (sessionExpiryTimer) {
+      clearTimeout(sessionExpiryTimer);
+    }
+    startSessionExpiryTimer();
+  };
+  const stopSessionExpiryTimer = () => {
+    if (sessionExpiryTimer) {
+      clearTimeout(sessionExpiryTimer);
+      sessionExpiryTimer = null;
+    } else {
+      log("No session expiry timer to stop");
+    }
+  };
+  const isSessionExpired = (sessionData) => {
+    if (!sessionData) {
+      log("No session data provided, considering expired");
+      return true;
+    }
+    const timeSinceLastActivity = now() - sessionData.lastActivity;
+    const totalSessionDuration = sessionData.sessionStartTime ? now() - sessionData.sessionStartTime : 0;
+    return timeSinceLastActivity > config.sessionTimeout || totalSessionDuration > config.sessionTimeout;
+  };
+  const fetchWithTimeout = async (url, options = {}, timeoutMs = 2e4) => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const mergedOptions = { ...options, signal: controller.signal };
+    try {
+      return await fetch(url, mergedOptions);
+    } catch (err) {
+      if (err instanceof DOMException && (err.name === "AbortError" || err.name === "TimeoutError")) {
+        return { ok: false, status: 0, statusText: "Aborted" };
+      }
+      if (typeof err === "object") {
+        const message = err.message || "";
+        if (message.includes("aborted") || message.includes("cancelled")) {
+          return { ok: false, status: 0, statusText: "Aborted" };
+        }
+      }
+      return { ok: false, status: 0, statusText: "Aborted" };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  };
+  const buildEndpointUrl = (baseEndpoint, requestType, keepalive, payloadSizeKB, isCompressed = false, sessionIdParam = null) => {
+    let url;
+    try {
+      url = new URL(baseEndpoint);
+    } catch {
+      return baseEndpoint;
+    }
+    const currentSessionId = sessionIdParam !== null ? sessionIdParam : sessionId;
+    url.searchParams.set(URL_PARAMS.VERSION, LIB_VERSION);
+    url.searchParams.set(URL_PARAMS.REQUEST_TYPE, requestType);
+    url.searchParams.set(
+      URL_PARAMS.KEEPALIVE,
+      keepalive === null ? "null" : String(keepalive)
+    );
+    url.searchParams.set(URL_PARAMS.SIZE, Math.round(payloadSizeKB).toString());
+    url.searchParams.set(URL_PARAMS.COMPRESSION, isCompressed ? "1" : "0");
+    if (currentSessionId) {
+      url.searchParams.set(URL_PARAMS.SESSION_ID, currentSessionId);
+    }
+    return url.toString();
+  };
+  const sendEvents = async (events) => {
+    if (!events || events.length === 0) {
+      log("No events to send, skipping network request");
+      return;
+    }
+    if (contractStatus) {
+      log("Events not sent - Contract issue:", contractStatus.message);
+      return;
+    }
+    if (quotaStatus) {
+      log("Events not sent - Quota exceeded:", quotaStatus.message);
+      return;
+    }
+    if (config.defaultSamplingPercent === 0) {
+      log("Events not sent - samplingPercent set to 0");
+      return;
+    }
+    if (!sessionId || !userId) {
+      error("Cannot send events: sessionId or userId not set");
+      return;
+    }
+    const capturedSessionId = sessionId;
+    const capturedUserId = userId;
+    const capturedExternalId = externalId;
+    const capturedOrganizationId = organizationId;
+    const eventsToSend = [...events];
+    const MAX_CHUNK_SIZE = 40 * BYTES_IN_KILOBYTE;
+    const basePayload = {
+      session_id: capturedSessionId,
+      user_id: capturedUserId,
+      organization_id: capturedOrganizationId,
+      events: [],
+      client_version: LIB_VERSION
+    };
+    if (capturedExternalId) {
+      basePayload.external_id = capturedExternalId;
+    }
+    const basePayloadString = JSON.stringify(basePayload);
+    const basePayloadSize = new Blob([basePayloadString]).size;
+    const fullPayloadString = JSON.stringify({
+      ...basePayload,
+      events: eventsToSend
+    });
+    const fullPayloadSize = new Blob([fullPayloadString]).size;
+    let chunks = [];
+    if (fullPayloadSize > MAX_CHUNK_SIZE) {
+      let currentChunk = [];
+      let currentChunkSize = basePayloadSize;
+      for (let i = 0; i < eventsToSend.length; i += 1) {
+        const testChunk = [...currentChunk, eventsToSend[i]];
+        const testPayloadSize = new Blob([
+          JSON.stringify({ ...basePayload, events: testChunk })
+        ]).size;
+        if (testPayloadSize > MAX_CHUNK_SIZE && currentChunk.length > 0) {
+          chunks.push([...currentChunk]);
+          currentChunk = [eventsToSend[i]];
+          currentChunkSize = new Blob([
+            JSON.stringify({ ...basePayload, events: currentChunk })
+          ]).size;
+        } else {
+          currentChunk = testChunk;
+          currentChunkSize = testPayloadSize;
+        }
+        void currentChunkSize;
+      }
+      if (currentChunk.length > 0) {
+        chunks.push(currentChunk);
+      }
+    } else {
+      chunks = [eventsToSend];
+    }
+    for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex += 1) {
+      const chunk = chunks[chunkIndex];
+      const chunkPayload = {
+        session_id: capturedSessionId,
+        user_id: capturedUserId,
+        organization_id: capturedOrganizationId,
+        events: chunk,
+        client_version: LIB_VERSION
+      };
+      if (capturedExternalId) {
+        chunkPayload.external_id = capturedExternalId;
+      }
+      const chunkPayloadString = JSON.stringify(chunkPayload);
+      try {
+        const compressionResult = config.debug ? {
+          body: chunkPayloadString,
+          compressed: false,
+          originalSize: new Blob([chunkPayloadString]).size
+        } : await compressGzip(chunkPayloadString);
+        const bodyToSend = compressionResult.body;
+        const bodySizeBytes = typeof bodyToSend === "string" ? new Blob([bodyToSend]).size : bodyToSend instanceof Blob ? bodyToSend.size : new Blob([bodyToSend]).size;
+        const payloadSizeKB = bodySizeBytes / BYTES_IN_KILOBYTE;
+        if (payloadSizeKB * BYTES_IN_KILOBYTE > MAX_CHUNK_SIZE) {
+          const endpointUrl = buildEndpointUrl(
+            config.endpoint,
+            "f",
+            false,
+            payloadSizeKB,
+            compressionResult.compressed,
+            capturedSessionId
+          );
+          const headers = {
+            "Content-Type": compressionResult.compressed ? "application/gzip" : "text/plain"
+          };
+          const response = await fetchWithTimeout(
+            endpointUrl,
+            {
+              method: "POST",
+              headers,
+              body: bodyToSend,
+              keepalive: false
+            },
+            2e4
+          );
+          if (response?.status === 0) {
+            continue;
+          }
+          if (response && !response.ok && response.status >= 500) {
+            error(`Failed to send chunk ${chunkIndex + 1}:`, response.status);
+          }
+        } else {
+          let sent = false;
+          if (isBrowser() && navigator.sendBeacon) {
+            try {
+              const endpointUrl2 = buildEndpointUrl(
+                config.endpoint,
+                "b",
+                null,
+                payloadSizeKB,
+                compressionResult.compressed,
+                capturedSessionId
+              );
+              sent = navigator.sendBeacon(endpointUrl2, bodyToSend);
+              if (sent) {
+                continue;
+              }
+            } catch (err) {
+              log(
+                "Compression failed for sendBeacon, falling back to fetch:",
+                err
+              );
+            }
+          } else {
+            log(
+              `sendBeacon not supported for chunk ${chunkIndex + 1}, using fetch`
+            );
+          }
+          const endpointUrl = buildEndpointUrl(
+            config.endpoint,
+            "f",
+            false,
+            payloadSizeKB,
+            compressionResult.compressed,
+            capturedSessionId
+          );
+          const headers = {
+            "Content-Type": compressionResult.compressed ? "application/gzip" : "text/plain"
+          };
+          fetchWithTimeout(
+            endpointUrl,
+            {
+              method: "POST",
+              headers,
+              body: bodyToSend,
+              keepalive: false
+            },
+            2e4
+          ).catch(() => {
+          });
+        }
+      } catch (err) {
+        const errorMessage = err?.message || "";
+        const isBlocked2 = errorMessage.includes("Failed to fetch") || errorMessage.includes("NetworkError") || errorMessage.includes("ERR_BLOCKED_BY_CLIENT") || errorMessage.includes("ERR_BLOCKED_BY_RESPONSE") || errorMessage.includes("net::ERR_FAILED");
+        const isAborted = err?.name === "AbortError" || err?.name === "TimeoutError" || errorMessage.includes("aborted") || errorMessage.includes("cancelled");
+        if (isBlocked2 || isAborted) {
+          return;
+        }
+        return;
+      }
+    }
+  };
+  const flushEvents = () => {
+    if (eventBuffer.length === 0) {
+      log("No events in buffer to flush");
+      return;
+    }
+    const eventsToSend = [...eventBuffer];
+    eventBuffer = [];
+    void sendEvents(eventsToSend);
+  };
+  const startFlushTimer = () => {
+    if (flushTimer) {
+      log("Clearing existing flush timer");
+      clearInterval(flushTimer);
+    }
+    flushTimer = setInterval(() => {
+      flushEvents();
+    }, config.flushInterval);
+  };
+  const stopFlushTimer = () => {
+    if (flushTimer) {
+      clearInterval(flushTimer);
+      flushTimer = null;
+    } else {
+      log("No flush timer to stop");
+    }
+  };
+  const loadRrweb = () => new Promise((resolve, reject) => {
+    if (!isBrowser()) {
+      reject(new Error("rrweb requires a browser environment"));
+      return;
+    }
+    if (window.rrweb) {
+      resolve(window.rrweb);
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = "https://app.infinitewatch.ai/rrweb.min.js";
+    script.onload = () => {
+      if (window.rrweb) {
+        resolve(window.rrweb);
+      } else {
+        reject(new Error("rrweb failed to load"));
+      }
+    };
+    script.onerror = () => reject(new Error("Failed to load rrweb script"));
+    document.head.appendChild(script);
+  });
+  const loadRrwebPacker = () => new Promise((resolve, reject) => {
+    try {
+      if (!isBrowser()) {
+        reject(new Error("rrweb packer requires a browser environment"));
+        return;
+      }
+      const existing = window.rrwebPack?.pack || window.pack;
+      if (typeof existing === "function") {
+        resolve(existing);
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = "https://app.infinitewatch.ai/rrweb-record-pack.min.js";
+      script.async = true;
+      script.onload = () => {
+        const packFn = window.rrwebRecord?.pack || window.pack;
+        if (typeof packFn === "function") {
+          resolve(packFn);
+        } else {
+          reject(
+            new Error("rrweb packer loaded but pack function not found")
+          );
+        }
+      };
+      script.onerror = () => reject(new Error("Failed to load rrweb packer script"));
+      document.head.appendChild(script);
+    } catch (e) {
+      reject(e);
+    }
+  });
+  const addEvent = async (event) => {
+    if (hardStop) return;
+    if (isSessionActive && sessionStartTime) {
+      const totalSessionDuration = now() - sessionStartTime;
+      if (totalSessionDuration > config.sessionTimeout) {
+        log("Session expired, stopping and restarting with new session");
+        stopRecordingSession();
+      }
+    }
+    if (!isSessionActive) {
+      if (stopRecording) {
+        stopRecording();
+        stopRecording = null;
+      }
+      sessionId = config.sessionId || generateSessionId();
+      userId = config.userId || getOrCreateUserId();
+      const previousSession = loadSessionFromStorage();
+      if (previousSession?.externalId) {
+        externalId = previousSession.externalId || null;
+      }
+      organizationId = config.organizationId;
+      sessionStartTime = now();
+      await startRecording();
+      return;
+    }
+    eventBuffer.push(event);
+    updateSessionActivity();
+    if (eventBuffer.length >= config.batchSize) {
+      log("Buffer size reached, triggering flush");
+      flushEvents();
+    } else {
+      log("Buffer not full yet, continuing to collect events");
+    }
+  };
+  const generateInsights = async (hardSessionId = null) => {
+    if (!config.generateInsights) {
+      return;
+    }
+    sessionId = hardSessionId || sessionId;
+    const event = {
+      type: 9999,
+      timestamp: now(),
+      data: {}
+    };
+    const payload = {
+      session_id: sessionId,
+      user_id: userId,
+      organization_id: organizationId,
+      events: [event],
+      client_version: LIB_VERSION
+    };
+    if (externalId) {
+      payload.external_id = externalId;
+    }
+    const payloadString = JSON.stringify(payload);
+    const payloadSizeKB = new Blob([payloadString]).size / BYTES_IN_KILOBYTE;
+    try {
+      const endpointUrl = buildEndpointUrl(
+        config.endpoint,
+        "f",
+        false,
+        payloadSizeKB,
+        false
+      );
+      const response = await fetch(endpointUrl, {
+        method: "POST",
+        headers: { "Content-Type": "text/plain" },
+        body: payloadString,
+        mode: "cors",
+        credentials: "omit"
+      });
+      if (response.status === 0) {
+        log("Insights request aborted (status 0)");
+      } else if (!response.ok && response.status >= 500) {
+        error("Failed to send insights with fetch:", response.status);
+      }
+    } catch (err) {
+      const errorMessage = err?.message || "";
+      const isBlocked2 = errorMessage.includes("Failed to fetch") || errorMessage.includes("NetworkError") || errorMessage.includes("ERR_BLOCKED_BY_CLIENT") || errorMessage.includes("ERR_BLOCKED_BY_RESPONSE") || errorMessage.includes("net::ERR_FAILED");
+      const isAborted = err?.name === "AbortError" || err?.name === "TimeoutError" || errorMessage.includes("aborted") || errorMessage.includes("cancelled");
+      if (isBlocked2 || isAborted) {
+        return;
+      }
+      return;
+    }
+  };
+  const startRecording = async () => {
+    if (isSessionActive) {
+      log("Recording already active, skipping startRecording");
+      return;
+    }
+    isSessionActive = true;
+    try {
+      const [packFn, rrweb] = await Promise.all([
+        loadRrwebPacker(),
+        loadRrweb()
+      ]);
+      const filterBlacklistedAttrMutations = (event) => {
+        const data = getMutationData(event);
+        if (!data) return event;
+        if (!Array.isArray(data.attributes)) {
+          return event;
+        }
+        const prefixes = Array.isArray(config.blackList) ? config.blackList.filter(
+          (p) => typeof p === "string" && p.length > 0
+        ) : [];
+        if (prefixes.length === 0) {
+          return event;
+        }
+        const startsWithBlacklisted = (idValue) => {
+          if (typeof idValue !== "string") return false;
+          for (const prefix of prefixes) {
+            if (idValue.startsWith(prefix)) return true;
+          }
+          return false;
+        };
+        const nextAttributes = data.attributes.filter((attrChange) => {
+          const elemId = attrChange?.attributes?.id;
+          return !startsWithBlacklisted(elemId);
+        });
+        const baseEvent = event;
+        const nextData = { ...data, attributes: nextAttributes };
+        const hasAdds = Array.isArray(nextData.adds) && nextData.adds.length > 0;
+        const hasRemoves = Array.isArray(nextData.removes) && nextData.removes.length > 0;
+        const hasTexts = Array.isArray(nextData.texts) && nextData.texts.length > 0;
+        const hasAttributes = Array.isArray(nextData.attributes) && nextData.attributes.length > 0;
+        if (!hasAdds && !hasRemoves && !hasTexts && !hasAttributes) {
+          return null;
+        }
+        return {
+          ...baseEvent,
+          data: nextData
+        };
+      };
+      const filterMutations = (event) => {
+        const data = getMutationData(event);
+        if (data) {
+          const attrs = data.attributes;
+          if (Array.isArray(attrs) && attrs.length) {
+            const filtered = attrs.filter((a) => {
+              const at = isRecord(a?.attributes) ? a.attributes : {};
+              const keys = Object.keys(at);
+              const onlyTransformOpacity = keys.length > 0 && keys.every((k) => k === "transform" || k === "opacity");
+              if (!onlyTransformOpacity) return true;
+              const id = at.id;
+              if (isInteractiveId(id)) return true;
+              return false;
+            });
+            if (filtered.length === 0) return null;
+            data.attributes = filtered;
+          }
+        }
+        return event;
+      };
+      const isNoisySvgAdd = (add) => {
+        const n = add?.node;
+        if (!n) return false;
+        if (!n.isSVG) return false;
+        const tag = (n.tagName || "").toLowerCase();
+        if (tag === "path" && typeof (isRecord(n.attributes) ? n.attributes.d : void 0) === "string" && (isRecord(n.attributes) ? String(n.attributes.d).length : 0) > 200)
+          return true;
+        if (tag === "style") return true;
+        return false;
+      };
+      const isUselessTextAdd = (add) => {
+        const n = add?.node;
+        return n?.type === 3 && (n.textContent === "" || n.textContent == null);
+      };
+      const filterAdds = (event) => {
+        const data = getMutationData(event);
+        if (!data) return event;
+        if (Array.isArray(data.adds) && data.adds.length) {
+          data.adds = data.adds.filter(
+            (add) => !isNoisySvgAdd(add) && !isUselessTextAdd(add)
+          );
+        }
+        const hasAdds = Array.isArray(data.adds) && data.adds.length > 0;
+        const hasRemoves = Array.isArray(data.removes) && data.removes.length > 0;
+        const hasTexts = Array.isArray(data.texts) && data.texts.length > 0;
+        const hasAttributes = Array.isArray(data.attributes) && data.attributes.length > 0;
+        if (!hasAdds && !hasRemoves && !hasTexts && !hasAttributes) {
+          return null;
+        }
+        return event;
+      };
+      const NET_SAMPLE_MS = 1e4;
+      const IDLE_MS = 15e3;
+      const BLOCKED_NET_HOSTS = /* @__PURE__ */ new Set([
+        "ingest.infinitewatch.ai",
+        "ingest.humanbehavior.co"
+      ]);
+      let __iw_lastUserIntentAt = now();
+      let __iw_intentInstalled = false;
+      const __iw_lastNetSentAt = /* @__PURE__ */ new Map();
+      const iwInstallUserIntentListenersOnce = () => {
+        if (__iw_intentInstalled || !isBrowser()) return;
+        __iw_intentInstalled = true;
+        const mark = () => {
+          __iw_lastUserIntentAt = now();
+        };
+        [
+          "pointerdown",
+          "mousedown",
+          "touchstart",
+          "keydown",
+          "wheel",
+          "scroll",
+          "input"
+        ].forEach((t) => {
+          window.addEventListener(t, mark, { capture: true, passive: true });
+        });
+      };
+      const iwKeyForRequest = (name) => {
+        try {
+          const u = new URL(name);
+          return u.hostname + u.pathname;
+        } catch {
+          return String(name || "");
+        }
+      };
+      const iwIsBlockedHost = (name) => {
+        try {
+          const host = new URL(name).hostname;
+          return BLOCKED_NET_HOSTS.has(host);
+        } catch {
+          return false;
+        }
+      };
+      const filterNetworkNoise = (event) => {
+        if (!event || event.type !== 6 || !event.data?.plugin || event.data.plugin !== "rrweb/network@1") {
+          return event;
+        }
+        if (now() - __iw_lastUserIntentAt > IDLE_MS) {
+          return null;
+        }
+        const payload = event.data?.payload;
+        const reqs = payload?.requests;
+        if (!Array.isArray(reqs) || reqs.length === 0) return event;
+        const timestamp = event.timestamp || now();
+        const filteredReqs = [];
+        for (const r of reqs) {
+          const name = r?.name;
+          if (typeof name !== "string") continue;
+          if (iwIsBlockedHost(name)) continue;
+          const key = iwKeyForRequest(name);
+          const last = __iw_lastNetSentAt.get(key) || 0;
+          if (timestamp - last < NET_SAMPLE_MS) continue;
+          __iw_lastNetSentAt.set(key, timestamp);
+          filteredReqs.push(r);
+        }
+        if (filteredReqs.length === 0) return null;
+        return {
+          ...event,
+          data: {
+            ...event.data,
+            payload: {
+              ...payload,
+              requests: filteredReqs
+            }
+          }
+        };
+      };
+      const ANIM_ATTR_KEYS = /* @__PURE__ */ new Set(["d"]);
+      const ANIM_STYLE_KEYS = /* @__PURE__ */ new Set([
+        "transform",
+        "opacity",
+        "filter",
+        "backdrop-filter",
+        "will-change",
+        "translate",
+        "scale",
+        "rotate"
+      ]);
+      const isAnimationOnlyAttrChange = (attrChange) => {
+        const attrs = attrChange?.attributes;
+        if (!attrs || typeof attrs !== "object") return false;
+        const keys = Object.keys(attrs);
+        const firstKey = keys[0];
+        if (keys.length === 1 && firstKey && ANIM_ATTR_KEYS.has(firstKey))
+          return true;
+        if (keys.length === 1 && firstKey === "style") {
+          const style = attrs.style;
+          if (!style || typeof style !== "object") return false;
+          const styleKeys = Object.keys(style);
+          if (styleKeys.length === 0) return false;
+          return styleKeys.every((k) => ANIM_STYLE_KEYS.has(k));
+        }
+        return keys.every((k) => ANIM_STYLE_KEYS.has(k));
+      };
+      const isPureAnimationMutationEvent = (event) => {
+        const data = getMutationData(event);
+        if (!data) return false;
+        const hasAdds = Array.isArray(data.adds) && data.adds.length > 0;
+        const hasRemoves = Array.isArray(data.removes) && data.removes.length > 0;
+        const hasTexts = Array.isArray(data.texts) && data.texts.length > 0;
+        if (hasAdds || hasRemoves || hasTexts) return false;
+        const attrs = data.attributes;
+        if (!Array.isArray(attrs) || attrs.length === 0) return false;
+        return attrs.every(isAnimationOnlyAttrChange);
+      };
+      const IDLE_MUTATION_SAMPLE_MS = 1500;
+      let __iw_lastKeptIdleAnimMutationAt = 0;
+      const sampleAnimationMutationsWhenIdle = (event) => {
+        if (!event || event.type !== 3 || event?.data?.source !== 0)
+          return event;
+        const idleFor = now() - __iw_lastUserIntentAt;
+        if (idleFor <= IDLE_MS) return event;
+        if (!isPureAnimationMutationEvent(event)) return event;
+        const ts = event.timestamp || now();
+        if (ts - __iw_lastKeptIdleAnimMutationAt < IDLE_MUTATION_SAMPLE_MS) {
+          return null;
+        }
+        __iw_lastKeptIdleAnimMutationAt = ts;
+        return event;
+      };
+      const dropIdleAnimationMutations = (event) => {
+        const data = getMutationData(event);
+        if (!data) return event;
+        const idleFor = now() - __iw_lastUserIntentAt;
+        if (idleFor > IDLE_MS && isPureAnimationMutationEvent(event))
+          return null;
+        return event;
+      };
+      const DROP_ATTR_KEYS = /* @__PURE__ */ new Set(["decoding", "data-hydrated"]);
+      const filterLowValueAttributes = (event) => {
+        const data = getMutationData(event);
+        if (!data) return event;
+        const attrs = data.attributes;
+        if (!Array.isArray(attrs) || attrs.length === 0) return event;
+        const next = [];
+        for (const a of attrs) {
+          const at = a?.attributes;
+          if (!at || typeof at !== "object") {
+            next.push(a);
+            continue;
+          }
+          const newAttrs = { ...at };
+          for (const k of Object.keys(newAttrs)) {
+            if (DROP_ATTR_KEYS.has(k)) delete newAttrs[k];
+          }
+          if ("preserveAspectRatio" in newAttrs && String(newAttrs.preserveAspectRatio).toLowerCase() === "none") {
+            delete newAttrs.preserveAspectRatio;
+          }
+          if ("width" in newAttrs && String(newAttrs.width) === "100%")
+            delete newAttrs.width;
+          if ("height" in newAttrs && String(newAttrs.height) === "100%")
+            delete newAttrs.height;
+          if (Object.keys(newAttrs).length === 0) continue;
+          next.push({ ...a, attributes: newAttrs });
+        }
+        data.attributes = next;
+        const empty = (!data.adds || data.adds.length === 0) && (!data.attributes || data.attributes.length === 0) && (!data.texts || data.texts.length === 0) && (!data.removes || data.removes.length === 0);
+        return empty ? null : event;
+      };
+      const filterIdleEvents = (event) => {
+        if (now() - __iw_lastUserIntentAt > IDLE_MS) {
+          if (event?.type === 3 && event?.data?.source === 0) {
+            const hasAdds = Array.isArray(event.data.adds) && event.data.adds.length > 0;
+            const hasRemoves = Array.isArray(event.data.removes) && event.data.removes.length > 0;
+            const hasTexts = Array.isArray(event.data.texts) && event.data.texts.length > 0;
+            if (hasAdds || hasRemoves || hasTexts) {
+              return event;
+            }
+          }
+          return null;
+        }
+        return event;
+      };
+      const filterEvent = (event) => {
+        let filtered = event;
+        if (filtered?.type === 5) return filtered;
+        filtered = filterIdleEvents(filtered);
+        if (!filtered) return null;
+        filtered = filterBlacklistedAttrMutations(filtered);
+        if (!filtered) return null;
+        filtered = filterMutations(filtered);
+        if (!filtered) return null;
+        filtered = filterAdds(filtered);
+        if (!filtered) return null;
+        filtered = filterNetworkNoise(filtered);
+        if (!filtered) return null;
+        filtered = sampleAnimationMutationsWhenIdle(filtered);
+        if (!filtered) return null;
+        filtered = dropIdleAnimationMutations(filtered);
+        if (!filtered) return null;
+        filtered = filterLowValueAttributes(filtered);
+        if (!filtered) return null;
+        return filtered;
+      };
+      const INTERACTIVE_SELECTOR = 'a,button,input,select,textarea,label,[role="button"],[role="link"],[tabindex],[contenteditable="true"]';
+      const isInteractiveEl = (el) => {
+        if (!el || el.nodeType !== 1) return false;
+        return !!(el.matches?.(INTERACTIVE_SELECTOR) || el.closest?.(INTERACTIVE_SELECTOR));
+      };
+      const onlyAnimationStyleChanged = (oldStyle = "", newStyle = "") => {
+        const toMap = (s) => s.split(";").map((x) => x.trim()).filter(Boolean).map((x) => x.split(":").map((y) => y.trim())).reduce((acc, [k, v]) => {
+          if (k) acc[k] = v ?? "";
+          return acc;
+        }, {});
+        const oldMap = toMap(oldStyle);
+        const newMap = toMap(newStyle);
+        const changedKeys = /* @__PURE__ */ new Set();
+        for (const k of /* @__PURE__ */ new Set([
+          ...Object.keys(oldMap),
+          ...Object.keys(newMap)
+        ])) {
+          if ((oldMap[k] ?? "") !== (newMap[k] ?? "")) changedKeys.add(k);
+        }
+        if (changedKeys.size === 0) return false;
+        const ANIM_STYLE_PROPS = [
+          "transform",
+          "opacity",
+          "will-change",
+          "filter",
+          "backdrop-filter",
+          "translate",
+          "scale",
+          "rotate"
+        ];
+        return [...changedKeys].every(
+          (k) => ANIM_STYLE_PROPS.some((p) => k.includes(p))
+        );
+      };
+      const INTERACTIVE_TAGS = /* @__PURE__ */ new Set([
+        "a",
+        "button",
+        "input",
+        "select",
+        "textarea",
+        "label"
+      ]);
+      const INTERACTIVE_ROLES = /* @__PURE__ */ new Set(["button", "link"]);
+      let __iw_idIsInteractive = /* @__PURE__ */ new Map();
+      const rebuildInteractiveIdMapFromFullSnapshot = (fsEvent) => {
+        __iw_idIsInteractive = /* @__PURE__ */ new Map();
+        const root = fsEvent?.data?.node;
+        if (!root) return;
+        const walk = (node, interactiveAncestor = false) => {
+          if (!node || typeof node !== "object") return;
+          if (node.type !== 2) {
+            if (node.childNodes) {
+              node.childNodes.forEach((ch) => {
+                walk(ch, interactiveAncestor);
+              });
+            }
+            return;
+          }
+          const tag = String(node.tagName || "").toLowerCase();
+          const attrs = node.attributes || {};
+          const id = attrs.id;
+          const selfInteractive = INTERACTIVE_TAGS.has(tag) || typeof attrs.role === "string" && INTERACTIVE_ROLES.has(String(attrs.role).toLowerCase()) || attrs.tabindex != null || attrs.href != null || String(attrs.contenteditable || "").toLowerCase() === "true";
+          const isInteractive = interactiveAncestor || selfInteractive;
+          if (typeof id === "string") {
+            __iw_idIsInteractive.set(id, isInteractive);
+          }
+          if (node.childNodes) {
+            node.childNodes.forEach((ch) => {
+              walk(ch, isInteractive);
+            });
+          }
+        };
+        walk(root, false);
+      };
+      const isInteractiveId = (id) => {
+        if (typeof id !== "string") return false;
+        return __iw_idIsInteractive.get(id) === true;
+      };
+      const emitUrlChangeEvent = () => {
+        const win = getWindow();
+        if (!win) return;
+        const url = win.location.href;
+        if (url === lastRecordedUrl) return;
+        lastRecordedUrl = url;
+        const customEvent = {
+          type: 5,
+          data: {
+            tag: "url-change",
+            url,
+            pathname: win.location.pathname,
+            search: win.location.search,
+            hash: win.location.hash
+          },
+          timestamp: Date.now(),
+          w_v: LIB_VERSION
+        };
+        void addEvent(customEvent);
+      };
+      const installUrlChangeListeners = () => {
+        const win = getWindow();
+        if (!win) return;
+        const originalPushState = win.history.pushState.bind(win.history);
+        const originalReplaceState = win.history.replaceState.bind(win.history);
+        win.history.pushState = (...args) => {
+          originalPushState(...args);
+          emitUrlChangeEvent();
+        };
+        win.history.replaceState = (...args) => {
+          originalReplaceState(...args);
+          emitUrlChangeEvent();
+        };
+        const popstateHandler = () => emitUrlChangeEvent();
+        win.addEventListener("popstate", popstateHandler);
+        urlChangeCleanup = () => {
+          win.history.pushState = originalPushState;
+          win.history.replaceState = originalReplaceState;
+          win.removeEventListener("popstate", popstateHandler);
+        };
+      };
+      const recordOptions = {
+        emit: (event) => {
+          if (event?.type === 2) {
+            rebuildInteractiveIdMapFromFullSnapshot(event);
+          }
+          const filtered = filterEvent(event);
+          if (filtered) {
+            try {
+              const win = getWindow();
+              const iwConfig = win ? win.__IW_CONFIG__ : void 0;
+              if (typeof iwConfig?.onEvent === "function") {
+                iwConfig.onEvent(filtered);
+              }
+            } catch {
+            }
+            filtered.w_v = LIB_VERSION;
+            const eventToAdd = config.debug ? filtered : packFn(filtered);
+            void addEvent(eventToAdd);
+            if (filtered.type === 2 && !lastRecordedUrl) {
+              const win = getWindow();
+              const url = win?.location?.href ?? "";
+              lastRecordedUrl = url;
+              const sessionStartedEvent = {
+                type: 5,
+                data: {
+                  tag: "session-started",
+                  url,
+                  pathname: win?.location?.pathname ?? "",
+                  search: win?.location?.search ?? "",
+                  hash: win?.location?.hash ?? ""
+                },
+                timestamp: Date.now(),
+                w_v: LIB_VERSION
+              };
+              void addEvent(sessionStartedEvent);
+            }
+          }
+        },
+        maskAllInputs: config.maskAllInputs,
+        maskInputOptions: config.maskInputOptions,
+        recordCanvas: config.recordCanvas,
+        recordIframe: config.recordIframe,
+        recordCrossOriginIframes: config.recordCrossOriginIframes,
+        collectFonts: false,
+        inlineStylesheet: config.inlineStylesheet,
+        slimDOM: true,
+        slimDOMOptions: {
+          script: true,
+          comment: true,
+          headFavicon: true,
+          headMETA: true,
+          headLink: true,
+          headScript: true,
+          headStyle: true,
+          iframe: true,
+          svg: true
+        },
+        sampling: {
+          mousemove: 300,
+          scroll: 300,
+          media: 3e3,
+          input: "last"
+        },
+        ignoreMutation: (m) => {
+          const t = m.target || null;
+          if (!t || t.nodeType !== 1) return false;
+          if (m.type === "attributes" && m.attributeName === "style") {
+            const oldStyle = m.oldValue ?? "";
+            const newStyle = t.getAttribute("style") ?? "";
+            if (onlyAnimationStyleChanged(oldStyle, newStyle) && !isInteractiveEl(t)) {
+              return true;
+            }
+          }
+          if (m.type === "childList" && m.addedNodes.length === 0 && m.removedNodes.length === 0) {
+            return true;
+          }
+          return false;
+        }
+      };
+      if (config.blockClass) {
+        recordOptions.blockClass = config.blockClass;
+      }
+      if (config.blockSelector) {
+        recordOptions.blockSelector = config.blockSelector;
+      }
+      if (config.maskTextSelector) {
+        recordOptions.maskTextSelector = config.maskTextSelector;
+      }
+      if (config.maskTextClass) {
+        recordOptions.maskTextClass = config.maskTextClass;
+      }
+      iwInstallUserIntentListenersOnce();
+      stopRecording = rrweb.record(recordOptions);
+      installUrlChangeListeners();
+      initSessionRecording();
+    } catch (err) {
+      error("Failed to start recording:", err);
+    }
+  };
+  const initSessionRecording = () => {
+    startSessionHeartbeat();
+    startSessionExpiryTimer();
+    saveSessionToStorage();
+    startFlushTimer();
+  };
+  const stopRecordingSession = () => {
+    stopSessionHeartbeat();
+    stopSessionExpiryTimer();
+    stopFlushTimer();
+    flushEvents();
+    clearSessionFromStorage();
+    if (urlChangeCleanup) {
+      urlChangeCleanup();
+      urlChangeCleanup = null;
+    }
+    lastRecordedUrl = "";
+    sessionId = null;
+    sessionStartTime = null;
+    isSessionActive = false;
+  };
+  const init = async (options) => {
+    if (!isBrowser()) {
+      return null;
+    }
+    if (isInitialized) {
+      log("Tracker already initialized");
+      return client;
+    }
+    if (!options.organizationId) {
+      console.error(
+        "[InfiniteWatch]",
+        "organizationId is required. Provide it as a prop/parameter or via an environment variable (e.g. NEXT_PUBLIC_INFINITEWATCH_ORG_ID or VITE_INFINITEWATCH_ORG_ID)."
+      );
+      return null;
+    }
+    if (isOrganizationExcluded(options.organizationId)) {
+      log("Organization excluded from tracking:", options.organizationId);
+      return null;
+    }
+    const initialConfig = { ...DEFAULT_CONFIG, ...options };
+    let recordingConfig = {};
+    if (initialConfig.endpointConfig && initialConfig.organizationId) {
+      try {
+        const response = await fetch(initialConfig.endpointConfig, {
+          method: "GET",
+          headers: {
+            "X-Organization": initialConfig.organizationId
+          },
+          credentials: "omit",
+          keepalive: false
+        });
+        if (response.status === 403) {
+          const errorData = await response.json();
+          contractStatus = {
+            error: errorData.error || "No active contract",
+            message: errorData.message || "Your contract has expired",
+            contract_expired: errorData.contract_expired || true
+          };
+          log(
+            "Contract expired or no active contract:",
+            contractStatus.message
+          );
+          return null;
+        } else if (response.status === 429) {
+          const errorData = await response.json();
+          quotaStatus = {
+            error: errorData.error || "Quota exceeded",
+            message: errorData.message || "You have reached your usage limit",
+            usage: errorData.usage || null,
+            upgrade_url: errorData.upgrade_url || null
+          };
+          log("Quota exceeded:", quotaStatus.message);
+          return null;
+        } else if (response.ok) {
+          const configData = await response.json();
+          const booleanFromConfig = (value, fallback) => {
+            if (value == null) return fallback;
+            if (value === "true") return true;
+            if (value === "false") return false;
+            return Boolean(value);
+          };
+          recordingConfig = {
+            defaultSamplingPercent: configData.samplingPercent ?? initialConfig.defaultSamplingPercent,
+            autoResumeSession: booleanFromConfig(
+              configData.autoResumeSession,
+              initialConfig.autoResumeSession
+            ),
+            batchSize: configData.batchSize ?? initialConfig.batchSize,
+            flushInterval: configData.flushInterval ?? initialConfig.flushInterval,
+            sessionTimeout: configData.sessionTimeout ?? initialConfig.sessionTimeout,
+            sessionHeartbeatInterval: configData.sessionHeartbeatInterval ?? initialConfig.sessionHeartbeatInterval,
+            inlineStylesheet: booleanFromConfig(
+              configData.inlineStylesheet,
+              initialConfig.inlineStylesheet
+            ),
+            generateInsights: booleanFromConfig(
+              configData.generateInsights,
+              initialConfig.generateInsights
+            )
+          };
+          options.defaultSamplingPercent = recordingConfig.defaultSamplingPercent;
+          options.autoResumeSession = recordingConfig.autoResumeSession;
+          options.batchSize = recordingConfig.batchSize;
+          options.flushInterval = recordingConfig.flushInterval;
+          options.sessionTimeout = recordingConfig.sessionTimeout;
+          options.sessionHeartbeatInterval = recordingConfig.sessionHeartbeatInterval;
+          options.inlineStylesheet = recordingConfig.inlineStylesheet;
+          options.generateInsights = recordingConfig.generateInsights;
+          options.blackList = recordingConfig.blackList;
+          switch (configData.masking) {
+            case "All":
+              options.maskTextSelector = "body";
+              break;
+            case "OnlyPasswords":
+              options.maskAllInputs = false;
+              options.maskInputOptions = {
+                password: true,
+                email: false,
+                text: false,
+                tel: false,
+                url: false,
+                textarea: false,
+                select: false,
+                checkbox: false,
+                radio: false,
+                file: false
+              };
+              break;
+          }
+        } else {
+          log("Config endpoint returned error:", response.status);
+        }
+      } catch (err) {
+        log("Failed to fetch endpoint config, using defaults:", err);
+      }
+    }
+    config = { ...DEFAULT_CONFIG, ...options };
+    if (config.autoResumeSession) {
+      const existingSession = loadSessionFromStorage();
+      if (existingSession && !isSessionExpired(existingSession)) {
+        sessionId = existingSession.sessionId;
+        userId = existingSession.userId;
+        externalId = existingSession.externalId || null;
+        organizationId = existingSession.organizationId || config.organizationId;
+        sessionStartTime = existingSession.sessionStartTime || now();
+        isSampledIn = true;
+      } else {
+        sessionId = config.sessionId || generateSessionId();
+        userId = config.userId || getOrCreateUserId();
+        const previousSession = loadSessionFromStorage();
+        if (previousSession?.externalId) {
+          externalId = previousSession.externalId || null;
+        }
+        organizationId = config.organizationId;
+        sessionStartTime = now();
+        isSampledIn = shouldSample(organizationId, sessionId);
+      }
+    } else {
+      sessionId = config.sessionId || generateSessionId();
+      userId = config.userId || getOrCreateUserId();
+      const previousSession = loadSessionFromStorage();
+      if (previousSession?.externalId) {
+        externalId = previousSession.externalId || null;
+      }
+      organizationId = config.organizationId;
+      sessionStartTime = now();
+      isSampledIn = shouldSample(organizationId, sessionId);
+    }
+    if (isSampledIn) {
+      startSessionExpiryTimer();
+    } else {
+      log("Session not sampled in; not starting expiry timer");
+    }
+    isInitialized = true;
+    window.addEventListener("beforeunload", () => {
+      flushEvents();
+      updateSessionActivity();
+      void generateInsights().catch(() => {
+      });
+    });
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "visible") {
+        if (isSessionActive && sessionStartTime) {
+          const totalSessionDuration = now() - sessionStartTime;
+          if (totalSessionDuration > config.sessionTimeout) {
+            log("Session expired while tab was backgrounded, stopping session");
+            stopRecordingSession();
+            return;
+          }
+        }
+        updateSessionActivity();
+      } else if (document.visibilityState === "hidden") {
+        void generateInsights().catch(() => {
+        });
+      }
+    });
+    return client;
+  };
+  const start = async () => {
+    if (!isInitialized) {
+      error("Tracker not initialized. Call init() first.");
+      return client;
+    }
+    if (contractStatus) {
+      log("Recording blocked - Contract issue:", contractStatus.message);
+      return client;
+    }
+    if (quotaStatus) {
+      log("Recording blocked - Quota exceeded:", quotaStatus.message);
+      return client;
+    }
+    if (config.defaultSamplingPercent === 0) {
+      log("Recording blocked - samplingPercent set to 0");
+      return client;
+    }
+    if (!isSampledIn) {
+      return client;
+    }
+    try {
+      await startRecording();
+    } catch (err) {
+      error("Failed to start recording:", err);
+    }
+    return client;
+  };
+  const stop = () => {
+    stopRecordingSession();
+    return client;
+  };
+  const hardStopSession = () => {
+    hardStop = true;
+    stopRecordingSession();
+    return client;
+  };
+  const flush = () => {
+    flushEvents();
+    return client;
+  };
+  const identify = (userIdentifier) => {
+    if (!userIdentifier || !userIdentifier.external_id) {
+      error("InfiniteWatch.identify: external_id is required");
+      return client;
+    }
+    if (!sessionId || !userId) {
+      error(
+        "InfiniteWatch.identify: No active session. Call init() and start() first."
+      );
+      return client;
+    }
+    if (!organizationId) {
+      organizationId = config.organizationId;
+    }
+    if (!organizationId) {
+      error(
+        "InfiniteWatch.identify: No organization ID set. Cannot identify user."
+      );
+      return client;
+    }
+    const doc = getDocument();
+    const win = getWindow();
+    if (!win) {
+      return client;
+    }
+    const nav = win.navigator ?? (typeof navigator !== "undefined" ? navigator : void 0);
+    const userLanguage = nav && "userLanguage" in nav ? nav.userLanguage : void 0;
+    const browserMetadata = {
+      user_agent: nav?.userAgent,
+      language: nav?.language || userLanguage,
+      languages: nav?.languages ? Array.from(nav.languages) : [],
+      platform: nav?.platform,
+      screen_width: win.screen?.width,
+      screen_height: win.screen?.height,
+      viewport_width: win.innerWidth,
+      viewport_height: win.innerHeight,
+      color_depth: win.screen?.colorDepth,
+      pixel_ratio: win.devicePixelRatio || 1,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      timezone_offset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+      url: win.location?.href,
+      pathname: win.location?.pathname,
+      referrer: doc?.referrer || null,
+      online: nav?.onLine,
+      cookie_enabled: nav?.cookieEnabled,
+      do_not_track: nav?.doNotTrack || null,
+      touch_support: "ontouchstart" in win || (nav?.maxTouchPoints ?? 0) > 0
+    };
+    const requestBody = {
+      external_id: userIdentifier.external_id,
+      session_id: sessionId,
+      user_id: userId,
+      organization_id: organizationId,
+      client_version: LIB_VERSION,
+      client_metadata: browserMetadata
+    };
+    for (const key in userIdentifier) {
+      if (key !== "external_id" && Object.hasOwn(userIdentifier, key)) {
+        requestBody[key] = userIdentifier[key];
+      }
+    }
+    const payloadString = JSON.stringify(requestBody);
+    const payloadSizeKB = new Blob([payloadString]).size / BYTES_IN_KILOBYTE;
+    const endpointUrl = buildEndpointUrl(
+      `${config.baseUrl}/v1/users`,
+      "f",
+      true,
+      payloadSizeKB,
+      false,
+      sessionId
+    );
+    fetch(endpointUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/plain"
+      },
+      body: payloadString,
+      keepalive: true
+    }).then((response) => {
+      if (response.status === 0) {
+        log("Identify request aborted (status 0)");
+      } else if (response.ok) {
+        externalId = userIdentifier.external_id;
+        saveSessionToStorage();
+        log("User identified successfully:", userIdentifier.external_id);
+      } else if (response.status >= 500) {
+        error("Failed to identify user:", response.status);
+      }
+    }).catch((err) => {
+      const errorMessage = err?.message || "";
+      const isBlocked2 = errorMessage.includes("Failed to fetch") || errorMessage.includes("NetworkError") || errorMessage.includes("ERR_BLOCKED_BY_CLIENT") || errorMessage.includes("ERR_BLOCKED_BY_RESPONSE") || errorMessage.includes("net::ERR_FAILED");
+      const isAborted = err?.name === "AbortError" || err?.name === "TimeoutError" || errorMessage.includes("aborted") || errorMessage.includes("cancelled");
+      if (!isBlocked2 && !isAborted) {
+        error("InfiniteWatch identify failed:", err);
+      }
+    });
+    return client;
+  };
+  const getSessionInfo = () => {
+    return {
+      sessionId,
+      userId,
+      organizationId,
+      sessionStartTime,
+      isActive: isSessionActive,
+      hasStoredSession: !!loadSessionFromStorage()
+    };
+  };
+  const isBlocked = () => {
+    return contractStatus !== null || quotaStatus !== null || config.defaultSamplingPercent === 0;
+  };
+  const getContractStatus = () => contractStatus;
+  const getQuotaStatus = () => quotaStatus;
+  const client = {
+    init,
+    start,
+    stop,
+    hardStop: hardStopSession,
+    flush,
+    identify,
+    getSessionInfo,
+    isBlocked,
+    getContractStatus,
+    getQuotaStatus
+  };
+  return client;
+};
+
+// src/index.ts
+var webCore = createWebCore();
+export {
+  createWebCore,
+  webCore
+};
+//# sourceMappingURL=index.js.map