@bentolabs/sdk 1.2.2 → 2.0.2

package/dist/index.js

@@ -51,7 +51,9 @@ var index_exports = {};
 __export(index_exports, {
   BentoLabsSDK: () => BentoLabsSDK,
   default: () => index_default,
-  generateSelector: () => generateSelector
+  generateSelector: () => generateSelector,
+  generateSelectorFromElement: () => generateSelectorFromElement,
+  generateSelectorFromHTML: () => generateSelectorFromHTML
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -9149,10 +9151,145 @@ function quickHash(str) {
   }
   return (hash >>> 0).toString(16);
 }
-function buildBentoSelector(element) {
+function getParentAcrossShadow(element) {
+  if (element.parentElement) {
+    return element.parentElement;
+  }
+  const root2 = element.getRootNode();
+  if (root2 instanceof ShadowRoot) {
+    return root2.host;
+  }
+  return null;
+}
+function isPortalContainer(element) {
+  return element.hasAttribute("data-radix-portal") || element.hasAttribute("data-headlessui-portal") || element.hasAttribute("data-floating-ui-portal") || element.hasAttribute("data-portal") || element.id !== "" && element.id.toLowerCase().includes("portal") || element.classList.contains("portal") || element.getAttribute("role") === "dialog";
+}
+function findUniqueAncestor(element, maxDepth = 5) {
+  let current = getParentAcrossShadow(element);
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    if (isPortalContainer(current)) {
+      current = getParentAcrossShadow(current);
+      continue;
+    }
+    const tag = current.tagName.toLowerCase();
+    if (current.id && isStableId(current.id)) {
+      return `${tag}#${current.id}`;
+    }
+    const testId = current.getAttribute("data-testid");
+    if (testId) {
+      return `${tag}[data-testid=${testId}]`;
+    }
+    const dataId = current.getAttribute("data-id");
+    if (dataId) {
+      return `${tag}[data-id=${dataId}]`;
+    }
+    const name = current.getAttribute("name");
+    if (name) {
+      return `${tag}[name=${name}]`;
+    }
+    current = getParentAcrossShadow(current);
+    depth++;
+  }
+  return null;
+}
+function findSection(element, maxDepth = 15) {
+  const sectionTags = [
+    "header",
+    "nav",
+    "main",
+    "aside",
+    "footer",
+    "section",
+    "article"
+  ];
+  let current = getParentAcrossShadow(element);
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    if (isPortalContainer(current)) {
+      current = getParentAcrossShadow(current);
+      continue;
+    }
+    const tag = current.tagName.toLowerCase();
+    if (sectionTags.includes(tag)) {
+      const label = current.getAttribute("aria-label");
+      return label ? `${tag}[${label}]` : tag;
+    }
+    current = getParentAcrossShadow(current);
+    depth++;
+  }
+  return null;
+}
+function findForm(element) {
+  const form = element.closest("form");
+  if (!form) return null;
+  if (form.id && isStableId(form.id)) return form.id;
+  if (form.name) return form.name;
+  return null;
+}
+function findRegion(element, maxDepth = 15) {
+  let current = getParentAcrossShadow(element);
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    if (isPortalContainer(current)) {
+      current = getParentAcrossShadow(current);
+      continue;
+    }
+    const role = current.getAttribute("role");
+    if (role === "region" || role === "navigation" || role === "banner" || role === "main" || role === "contentinfo" || role === "complementary") {
+      const label = current.getAttribute("aria-label");
+      return label ? `${role}[${label}]` : role;
+    }
+    current = getParentAcrossShadow(current);
+    depth++;
+  }
+  return null;
+}
+function getNthPosition(element) {
+  const parent = element.parentElement;
+  if (!parent) return 1;
+  const tag = element.tagName;
+  const text = getFullText$1(element);
+  let position = 0;
+  for (const sibling of Array.from(parent.children)) {
+    if (sibling.tagName === tag && getFullText$1(sibling) === text) {
+      position++;
+      if (sibling === element) return position;
+    }
+  }
+  return 1;
+}
+function buildBentoSelector(element, pathname) {
   const parts = [];
   const tag = element.tagName.toLowerCase();
   parts.push(tag);
+  if (pathname) {
+    parts.push(`page=${escapeValue(pathname)}`);
+  }
+  let hasContext = false;
+  const ancestor = findUniqueAncestor(element, 5);
+  if (ancestor) {
+    parts.push(`ancestor=${escapeValue(ancestor)}`);
+    hasContext = true;
+  } else {
+    const section = findSection(element, 15);
+    if (section) {
+      parts.push(`section=${escapeValue(section)}`);
+      hasContext = true;
+    } else {
+      const form = findForm(element);
+      if (form) {
+        parts.push(`form=${escapeValue(form)}`);
+        hasContext = true;
+      } else {
+        const region = findRegion(element, 15);
+        if (region) {
+          parts.push(`region=${escapeValue(region)}`);
+          hasContext = true;
+        }
+      }
+    }
+  }
   const testId = element.getAttribute("data-testid");
   if (testId) {
     parts.push(`testid=${escapeValue(truncate(testId, 50))}`);
@@ -9227,7 +9364,13 @@ function buildBentoSelector(element) {
       parts.push(`text=${escapeValue(truncate(text, 50))}`);
     }
   }
-  if (parts.length === 1) {
+  if (!hasContext) {
+    const nth = getNthPosition(element);
+    if (nth > 1) {
+      parts.push(`nth=${nth}`);
+    }
+  }
+  if (parts.length === 1 || parts.length === 2 && pathname) {
     const childSig = getChildSignature(element);
     if (childSig) {
       parts.push(`children=${childSig}`);
@@ -9238,7 +9381,11 @@ function buildBentoSelector(element) {
   }
   return parts.join("|");
 }
-function generateSelector(outerHTML) {
+function generateSelectorFromElement(element, pathname) {
+  const path = pathname != null ? pathname : typeof window !== "undefined" ? window.location.pathname : void 0;
+  return buildBentoSelector(element, path);
+}
+function generateSelectorFromHTML(outerHTML) {
   const parser2 = new DOMParser();
   const doc = parser2.parseFromString(outerHTML, "text/html");
   const element = doc.body.firstElementChild;
@@ -9247,6 +9394,9 @@ function generateSelector(outerHTML) {
   }
   return buildBentoSelector(element);
 }
+function generateSelector(outerHTML) {
+  return generateSelectorFromHTML(outerHTML);
+}
 var DEFAULT_OPTIONS = {
   maxTextLength: 500,
   includeOuterHTML: true,
@@ -9276,6 +9426,7 @@ function isInputElement(element) {
   return tagName === "INPUT" || tagName === "TEXTAREA" || tagName === "SELECT";
 }
 function extractElementContext(element, options = {}) {
+  var _a2;
   const opts = __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), options.elementContextOptions);
   const {
     isClickEvent = false,
@@ -9339,7 +9490,8 @@ function extractElementContext(element, options = {}) {
   }
   if (isClickEvent) {
     try {
-      context.bentoSelector = buildBentoSelector(element);
+      const path = (_a2 = options.pathname) != null ? _a2 : typeof window !== "undefined" ? window.location.pathname : void 0;
+      context.bentoSelector = buildBentoSelector(element, path);
     } catch (e) {
     }
   }
@@ -10175,6 +10327,7 @@ function initMouseInteractionObserver({
   let currentPointerType = null;
   const getHandler = (eventKey) => {
     return (event) => {
+      const pathname = typeof window !== "undefined" ? window.location.pathname : void 0;
       const target = getEventTarget(event);
       if (isBlocked(target, blockClass, blockSelector, true)) {
         return;
@@ -10225,7 +10378,9 @@ function initMouseInteractionObserver({
           elementContextOptions,
           isClickEvent,
           maskInputOptions,
-          maskInputFn
+          maskInputFn,
+          pathname
+          // Pass pathname captured at event time
         });
       }
       callbackWrapper(mouseInteractionCb)(__spreadValues(__spreadValues({
@@ -12620,6 +12775,641 @@ var { freezePage } = record;
 var { takeFullSnapshot } = record;
 
 // src/index.ts
+var PERSISTENCE_KEYS = {
+  DISTINCT_ID: "bentolabs_distinct_id",
+  SUPER_PROPERTIES: "bentolabs_super_properties",
+  OPTED_OUT: "bentolabs_opted_out",
+  USER_PROPERTIES: "bentolabs_user_properties",
+  IS_IDENTIFIED: "bentolabs_is_identified"
+};
+var Persistence = class {
+  constructor(mode) {
+    this.mode = mode;
+    this.memoryStorage = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    if (this.mode === "none") return null;
+    if (this.mode === "memory") {
+      return this.memoryStorage.get(key) || null;
+    }
+    if (this.mode === "localStorage" || this.mode === "localStorage+cookie") {
+      try {
+        const value = localStorage.getItem(key);
+        if (value !== null) return value;
+      } catch (e) {
+      }
+    }
+    if (this.mode === "cookie" || this.mode === "localStorage+cookie") {
+      try {
+        const cookies = document.cookie.split(";");
+        for (const cookie of cookies) {
+          const [cookieKey, cookieValue] = cookie.trim().split("=");
+          if (cookieKey === key) {
+            return decodeURIComponent(cookieValue);
+          }
+        }
+      } catch (e) {
+      }
+    }
+    return null;
+  }
+  set(key, value) {
+    if (this.mode === "none") return;
+    if (this.mode === "memory") {
+      this.memoryStorage.set(key, value);
+      return;
+    }
+    if (this.mode === "localStorage" || this.mode === "localStorage+cookie") {
+      try {
+        localStorage.setItem(key, value);
+      } catch (e) {
+      }
+    }
+    if (this.mode === "cookie" || this.mode === "localStorage+cookie") {
+      try {
+        const expires = /* @__PURE__ */ new Date();
+        expires.setFullYear(expires.getFullYear() + 1);
+        document.cookie = `${key}=${encodeURIComponent(value)};expires=${expires.toUTCString()};path=/;SameSite=Lax`;
+      } catch (e) {
+      }
+    }
+  }
+  remove(key) {
+    if (this.mode === "none") return;
+    if (this.mode === "memory") {
+      this.memoryStorage.delete(key);
+      return;
+    }
+    if (this.mode === "localStorage" || this.mode === "localStorage+cookie") {
+      try {
+        localStorage.removeItem(key);
+      } catch (e) {
+      }
+    }
+    if (this.mode === "cookie" || this.mode === "localStorage+cookie") {
+      try {
+        document.cookie = `${key}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/`;
+      } catch (e) {
+      }
+    }
+  }
+  clear() {
+    if (this.mode === "memory") {
+      this.memoryStorage.clear();
+      return;
+    }
+    Object.values(PERSISTENCE_KEYS).forEach((key) => this.remove(key));
+  }
+};
+var NetworkMonitor = class {
+  constructor(options, onCapture) {
+    this.logs = [];
+    this.originalFetch = null;
+    this.originalXHROpen = null;
+    this.originalXHRSend = null;
+    this.isMonitoring = false;
+    var _a2, _b, _c, _d;
+    this.options = {
+      skipUrls: options.skipUrls || ["api.bentolabs.ai"],
+      captureHeaders: (_a2 = options.captureHeaders) != null ? _a2 : false,
+      captureBody: (_b = options.captureBody) != null ? _b : false,
+      maxBodySize: (_c = options.maxBodySize) != null ? _c : 5e3,
+      sampleRate: (_d = options.sampleRate) != null ? _d : 1
+    };
+    this.onCapture = onCapture;
+  }
+  start() {
+    if (this.isMonitoring || typeof window === "undefined") return;
+    this.isMonitoring = true;
+    this.interceptFetch();
+    this.interceptXHR();
+  }
+  stop() {
+    if (!this.isMonitoring) return;
+    this.isMonitoring = false;
+    this.restoreFetch();
+    this.restoreXHR();
+  }
+  getLogs() {
+    return [...this.logs];
+  }
+  clearLogs() {
+    this.logs = [];
+  }
+  shouldSkip(url) {
+    return this.options.skipUrls.some((skipUrl) => url.includes(skipUrl));
+  }
+  shouldSample() {
+    return Math.random() < this.options.sampleRate;
+  }
+  sanitizeUrl(url) {
+    try {
+      const urlObj = new URL(url, window.location.origin);
+      const sensitiveParams = ["token", "key", "secret", "password", "auth", "apikey", "api_key"];
+      sensitiveParams.forEach((param) => {
+        if (urlObj.searchParams.has(param)) {
+          urlObj.searchParams.set(param, "[REDACTED]");
+        }
+      });
+      return urlObj.toString();
+    } catch (e) {
+      return url;
+    }
+  }
+  interceptFetch() {
+    if (typeof fetch === "undefined") return;
+    this.originalFetch = fetch.bind(window);
+    const self = this;
+    window.fetch = async function(input2, init) {
+      const url = typeof input2 === "string" ? input2 : input2 instanceof URL ? input2.toString() : input2.url;
+      if (self.shouldSkip(url) || !self.shouldSample()) {
+        return self.originalFetch(input2, init);
+      }
+      const startTime = Date.now();
+      const method = (init == null ? void 0 : init.method) || "GET";
+      try {
+        const response = await self.originalFetch(input2, init);
+        const duration = Date.now() - startTime;
+        const log = {
+          url: self.sanitizeUrl(url),
+          method: method.toUpperCase(),
+          status: response.status,
+          duration,
+          responseSize: parseInt(response.headers.get("content-length") || "0", 10),
+          initiator: "fetch",
+          timestamp: Date.now()
+        };
+        self.logs.push(log);
+        if (self.logs.length > 500) self.logs.shift();
+        self.onCapture(log);
+        return response;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        const log = {
+          url: self.sanitizeUrl(url),
+          method: method.toUpperCase(),
+          status: 0,
+          duration,
+          responseSize: 0,
+          initiator: "fetch",
+          error: error instanceof Error ? error.message : "Unknown error",
+          timestamp: Date.now()
+        };
+        self.logs.push(log);
+        if (self.logs.length > 500) self.logs.shift();
+        self.onCapture(log);
+        throw error;
+      }
+    };
+  }
+  restoreFetch() {
+    if (this.originalFetch && typeof window !== "undefined") {
+      window.fetch = this.originalFetch;
+      this.originalFetch = null;
+    }
+  }
+  interceptXHR() {
+    if (typeof XMLHttpRequest === "undefined") return;
+    this.originalXHROpen = XMLHttpRequest.prototype.open;
+    this.originalXHRSend = XMLHttpRequest.prototype.send;
+    const self = this;
+    XMLHttpRequest.prototype.open = function(method, url, async, username, password) {
+      this._bentoUrl = url.toString();
+      this._bentoMethod = method;
+      this._bentoStartTime = 0;
+      return self.originalXHROpen.call(this, method, url, async != null ? async : true, username, password);
+    };
+    XMLHttpRequest.prototype.send = function(body) {
+      const xhr = this;
+      const url = xhr._bentoUrl;
+      if (self.shouldSkip(url) || !self.shouldSample()) {
+        return self.originalXHRSend.call(this, body);
+      }
+      xhr._bentoStartTime = Date.now();
+      const handleLoadEnd = () => {
+        const duration = Date.now() - xhr._bentoStartTime;
+        const log = {
+          url: self.sanitizeUrl(url),
+          method: xhr._bentoMethod.toUpperCase(),
+          status: xhr.status,
+          duration,
+          responseSize: parseInt(xhr.getResponseHeader("content-length") || "0", 10),
+          initiator: "xhr",
+          timestamp: Date.now()
+        };
+        if (xhr.status === 0) {
+          log.error = "Request failed or was aborted";
+        }
+        self.logs.push(log);
+        if (self.logs.length > 500) self.logs.shift();
+        self.onCapture(log);
+      };
+      xhr.addEventListener("loadend", handleLoadEnd);
+      return self.originalXHRSend.call(this, body);
+    };
+  }
+  restoreXHR() {
+    if (this.originalXHROpen) {
+      XMLHttpRequest.prototype.open = this.originalXHROpen;
+      this.originalXHROpen = null;
+    }
+    if (this.originalXHRSend) {
+      XMLHttpRequest.prototype.send = this.originalXHRSend;
+      this.originalXHRSend = null;
+    }
+  }
+};
+var StorageMonitor = class {
+  constructor(options, onCapture) {
+    this.logs = [];
+    this.isMonitoring = false;
+    this.originalLocalStorage = null;
+    this.originalSessionStorage = null;
+    this.originalCookieDescriptor = null;
+    var _a2, _b, _c;
+    this.options = {
+      localStorage: (_a2 = options.localStorage) != null ? _a2 : true,
+      sessionStorage: (_b = options.sessionStorage) != null ? _b : true,
+      cookies: (_c = options.cookies) != null ? _c : true,
+      sensitiveKeys: options.sensitiveKeys || ["password", "token", "secret", "api_key", "apikey", "auth", "credential"]
+    };
+    this.onCapture = onCapture;
+  }
+  start() {
+    if (this.isMonitoring || typeof window === "undefined") return;
+    this.isMonitoring = true;
+    if (this.options.localStorage) this.interceptLocalStorage();
+    if (this.options.sessionStorage) this.interceptSessionStorage();
+    if (this.options.cookies) this.interceptCookies();
+  }
+  stop() {
+    if (!this.isMonitoring) return;
+    this.isMonitoring = false;
+    this.restoreLocalStorage();
+    this.restoreSessionStorage();
+    this.restoreCookies();
+  }
+  getLogs() {
+    return [...this.logs];
+  }
+  clearLogs() {
+    this.logs = [];
+  }
+  isSensitiveKey(key) {
+    const lowerKey = key.toLowerCase();
+    return this.options.sensitiveKeys.some((sensitive) => lowerKey.includes(sensitive.toLowerCase()));
+  }
+  addLog(log) {
+    if (this.isSensitiveKey(log.key) || log.key.startsWith("bentolabs_")) return;
+    this.logs.push(log);
+    if (this.logs.length > 500) this.logs.shift();
+    this.onCapture(log);
+  }
+  interceptLocalStorage() {
+    if (typeof localStorage === "undefined") return;
+    const self = this;
+    this.originalLocalStorage = {
+      setItem: localStorage.setItem.bind(localStorage),
+      getItem: localStorage.getItem.bind(localStorage),
+      removeItem: localStorage.removeItem.bind(localStorage),
+      clear: localStorage.clear.bind(localStorage)
+    };
+    localStorage.setItem = function(key, value) {
+      self.addLog({
+        storageType: "localStorage",
+        operation: "set",
+        key,
+        valueType: typeof value,
+        timestamp: Date.now()
+      });
+      return self.originalLocalStorage.setItem(key, value);
+    };
+    localStorage.getItem = function(key) {
+      self.addLog({
+        storageType: "localStorage",
+        operation: "get",
+        key,
+        timestamp: Date.now()
+      });
+      return self.originalLocalStorage.getItem(key);
+    };
+    localStorage.removeItem = function(key) {
+      self.addLog({
+        storageType: "localStorage",
+        operation: "remove",
+        key,
+        timestamp: Date.now()
+      });
+      return self.originalLocalStorage.removeItem(key);
+    };
+    localStorage.clear = function() {
+      self.addLog({
+        storageType: "localStorage",
+        operation: "clear",
+        key: "*",
+        timestamp: Date.now()
+      });
+      return self.originalLocalStorage.clear();
+    };
+  }
+  restoreLocalStorage() {
+    if (this.originalLocalStorage && typeof localStorage !== "undefined") {
+      localStorage.setItem = this.originalLocalStorage.setItem;
+      localStorage.getItem = this.originalLocalStorage.getItem;
+      localStorage.removeItem = this.originalLocalStorage.removeItem;
+      localStorage.clear = this.originalLocalStorage.clear;
+      this.originalLocalStorage = null;
+    }
+  }
+  interceptSessionStorage() {
+    if (typeof sessionStorage === "undefined") return;
+    const self = this;
+    this.originalSessionStorage = {
+      setItem: sessionStorage.setItem.bind(sessionStorage),
+      getItem: sessionStorage.getItem.bind(sessionStorage),
+      removeItem: sessionStorage.removeItem.bind(sessionStorage),
+      clear: sessionStorage.clear.bind(sessionStorage)
+    };
+    sessionStorage.setItem = function(key, value) {
+      self.addLog({
+        storageType: "sessionStorage",
+        operation: "set",
+        key,
+        valueType: typeof value,
+        timestamp: Date.now()
+      });
+      return self.originalSessionStorage.setItem(key, value);
+    };
+    sessionStorage.getItem = function(key) {
+      self.addLog({
+        storageType: "sessionStorage",
+        operation: "get",
+        key,
+        timestamp: Date.now()
+      });
+      return self.originalSessionStorage.getItem(key);
+    };
+    sessionStorage.removeItem = function(key) {
+      self.addLog({
+        storageType: "sessionStorage",
+        operation: "remove",
+        key,
+        timestamp: Date.now()
+      });
+      return self.originalSessionStorage.removeItem(key);
+    };
+    sessionStorage.clear = function() {
+      self.addLog({
+        storageType: "sessionStorage",
+        operation: "clear",
+        key: "*",
+        timestamp: Date.now()
+      });
+      return self.originalSessionStorage.clear();
+    };
+  }
+  restoreSessionStorage() {
+    if (this.originalSessionStorage && typeof sessionStorage !== "undefined") {
+      sessionStorage.setItem = this.originalSessionStorage.setItem;
+      sessionStorage.getItem = this.originalSessionStorage.getItem;
+      sessionStorage.removeItem = this.originalSessionStorage.removeItem;
+      sessionStorage.clear = this.originalSessionStorage.clear;
+      this.originalSessionStorage = null;
+    }
+  }
+  interceptCookies() {
+    if (typeof document === "undefined") return;
+    const self = this;
+    const descriptor = Object.getOwnPropertyDescriptor(Document.prototype, "cookie");
+    if (!descriptor) return;
+    this.originalCookieDescriptor = descriptor;
+    Object.defineProperty(document, "cookie", {
+      get: function() {
+        return self.originalCookieDescriptor.get.call(this);
+      },
+      set: function(value) {
+        const name = value.split("=")[0].trim();
+        self.addLog({
+          storageType: "cookie",
+          operation: "set",
+          key: name,
+          timestamp: Date.now()
+        });
+        return self.originalCookieDescriptor.set.call(this, value);
+      },
+      configurable: true
+    });
+  }
+  restoreCookies() {
+    if (this.originalCookieDescriptor && typeof document !== "undefined") {
+      Object.defineProperty(document, "cookie", this.originalCookieDescriptor);
+      this.originalCookieDescriptor = null;
+    }
+  }
+};
+var ConsoleMonitor = class {
+  constructor(options, onCapture) {
+    this.logs = [];
+    this.isMonitoring = false;
+    this.inStack = false;
+    this.originalConsole = null;
+    this.originalOnError = null;
+    this.originalOnUnhandledRejection = null;
+    var _a2, _b, _c;
+    this.options = {
+      levels: options.levels || ["log", "warn", "error", "info"],
+      maxLogs: (_a2 = options.maxLogs) != null ? _a2 : 500,
+      maxPayloadSize: (_b = options.maxPayloadSize) != null ? _b : 5e3,
+      captureStackTrace: (_c = options.captureStackTrace) != null ? _c : true
+    };
+    this.onCapture = onCapture;
+  }
+  start() {
+    if (this.isMonitoring || typeof console === "undefined") return;
+    this.isMonitoring = true;
+    this.interceptConsole();
+    this.interceptGlobalErrors();
+  }
+  stop() {
+    if (!this.isMonitoring) return;
+    this.isMonitoring = false;
+    this.restoreConsole();
+    this.restoreGlobalErrors();
+  }
+  getLogs() {
+    return [...this.logs];
+  }
+  clearLogs() {
+    this.logs = [];
+  }
+  stringifyArg(arg, seen = /* @__PURE__ */ new WeakSet()) {
+    if (arg === null) return "null";
+    if (arg === void 0) return "undefined";
+    const type = typeof arg;
+    if (type === "string") return arg;
+    if (type === "number" || type === "boolean") return String(arg);
+    if (type === "function") return `[Function: ${arg.name || "anonymous"}]`;
+    if (type === "symbol") return arg.toString();
+    if (type === "object") {
+      if (seen.has(arg)) return "[Circular]";
+      seen.add(arg);
+      if (arg instanceof Error) {
+        return `${arg.name}: ${arg.message}`;
+      }
+      try {
+        const str = JSON.stringify(arg, (key, value) => {
+          if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) return "[Circular]";
+            seen.add(value);
+          }
+          if (typeof value === "function") return `[Function: ${value.name || "anonymous"}]`;
+          if (typeof value === "symbol") return value.toString();
+          return value;
+        });
+        return str.length > this.options.maxPayloadSize ? str.slice(0, this.options.maxPayloadSize) + "..." : str;
+      } catch (e) {
+        return "[Object]";
+      }
+    }
+    return String(arg);
+  }
+  getStackTrace() {
+    if (!this.options.captureStackTrace) return [];
+    try {
+      const stack = new Error().stack || "";
+      const lines = stack.split("\n").slice(3);
+      return lines.slice(0, 5).map((line) => line.trim());
+    } catch (e) {
+      return [];
+    }
+  }
+  addLog(level, args) {
+    if (this.inStack) return;
+    this.inStack = true;
+    try {
+      const payload = args.map((arg) => this.stringifyArg(arg));
+      const log = {
+        level,
+        payload,
+        trace: this.getStackTrace(),
+        timestamp: Date.now()
+      };
+      this.logs.push(log);
+      if (this.logs.length > this.options.maxLogs) this.logs.shift();
+      this.onCapture(log);
+    } finally {
+      this.inStack = false;
+    }
+  }
+  interceptConsole() {
+    const self = this;
+    this.originalConsole = {
+      log: console.log.bind(console),
+      warn: console.warn.bind(console),
+      error: console.error.bind(console),
+      info: console.info.bind(console),
+      debug: console.debug.bind(console)
+    };
+    const levels = this.options.levels;
+    if (levels.includes("log")) {
+      console.log = function(...args) {
+        self.addLog("log", args);
+        return self.originalConsole.log(...args);
+      };
+    }
+    if (levels.includes("warn")) {
+      console.warn = function(...args) {
+        self.addLog("warn", args);
+        return self.originalConsole.warn(...args);
+      };
+    }
+    if (levels.includes("error")) {
+      console.error = function(...args) {
+        self.addLog("error", args);
+        return self.originalConsole.error(...args);
+      };
+    }
+    if (levels.includes("info")) {
+      console.info = function(...args) {
+        self.addLog("info", args);
+        return self.originalConsole.info(...args);
+      };
+    }
+    if (levels.includes("debug")) {
+      console.debug = function(...args) {
+        self.addLog("debug", args);
+        return self.originalConsole.debug(...args);
+      };
+    }
+  }
+  restoreConsole() {
+    if (this.originalConsole) {
+      console.log = this.originalConsole.log;
+      console.warn = this.originalConsole.warn;
+      console.error = this.originalConsole.error;
+      console.info = this.originalConsole.info;
+      console.debug = this.originalConsole.debug;
+      this.originalConsole = null;
+    }
+  }
+  interceptGlobalErrors() {
+    if (typeof window === "undefined") return;
+    const self = this;
+    this.originalOnError = window.onerror;
+    window.onerror = function(message, source, lineno, colno, error) {
+      self.addLog("error", [
+        `Uncaught error: ${message}`,
+        `at ${source}:${lineno}:${colno}`,
+        (error == null ? void 0 : error.stack) || ""
+      ]);
+      if (self.originalOnError && typeof self.originalOnError === "function") {
+        return self.originalOnError(message, source, lineno, colno, error);
+      }
+      return false;
+    };
+    this.originalOnUnhandledRejection = window.onunhandledrejection;
+    window.onunhandledrejection = function(event) {
+      self.addLog("error", [`Unhandled promise rejection: ${self.stringifyArg(event.reason)}`]);
+      if (self.originalOnUnhandledRejection) {
+        self.originalOnUnhandledRejection(event);
+      }
+    };
+  }
+  restoreGlobalErrors() {
+    if (typeof window === "undefined") return;
+    if (this.originalOnError !== null) {
+      window.onerror = this.originalOnError;
+      this.originalOnError = null;
+    }
+    if (this.originalOnUnhandledRejection !== null) {
+      window.onunhandledrejection = this.originalOnUnhandledRejection;
+      this.originalOnUnhandledRejection = null;
+    }
+  }
+};
+var PeopleAPI = class {
+  constructor(sdk2) {
+    this.sdk = sdk2;
+  }
+  /**
+   * Set properties on the current user
+   */
+  set(properties) {
+    this.sdk.capture("$set", { $set: properties });
+  }
+  /**
+   * Set properties on the current user only if they haven't been set already
+   */
+  setOnce(properties) {
+    this.sdk.capture("$set", { $set_once: properties });
+  }
+  /**
+   * Remove properties from the current user
+   */
+  unset(propertyNames) {
+    this.sdk.capture("$set", { $unset: propertyNames });
+  }
+};
 var BentoLabsSDK = class {
   constructor() {
     this.config = {
@@ -12628,43 +13418,115 @@ var BentoLabsSDK = class {
       debug: false,
       batchSize: 50,
       batchInterval: 1e4,
-      // 10 seconds
       enableRecording: true,
       maxRetries: 3,
-      baseRetryDelay: 1e3
+      baseRetryDelay: 1e3,
+      enableCompression: true,
+      // PostHog-like defaults
+      persistence: "localStorage+cookie",
+      respect_dnt: false,
+      autocapture: true,
+      capture_pageview: true,
+      capture_pageleave: true,
+      // Monitoring defaults
+      capture_network: true,
+      networkOptions: {
+        skipUrls: ["api.bentolabs.ai"],
+        captureHeaders: false,
+        captureBody: false,
+        maxBodySize: 5e3,
+        sampleRate: 1
+      },
+      capture_storage: true,
+      storageOptions: {
+        localStorage: true,
+        sessionStorage: true,
+        cookies: true,
+        sensitiveKeys: ["password", "token", "secret", "api_key", "apikey", "auth", "credential"]
+      },
+      capture_console: true,
+      consoleOptions: {
+        levels: ["log", "warn", "error", "info"],
+        maxLogs: 500,
+        maxPayloadSize: 5e3,
+        captureStackTrace: true
+      }
     };
     this.sessionId = "";
     this.events = [];
     this.isRecording = false;
     this.batchTimer = null;
     this.retryTimer = null;
-    this.stopRecording = null;
+    this.isSending = false;
+    this.stopRecordingFn = null;
+    this.distinctId = "";
+    this.identity = {
+      distinctId: null,
+      properties: {},
+      isIdentified: false
+    };
+    this.superProperties = {};
+    this.persistence = null;
+    this.initialized = false;
+    this.optedOut = false;
+    this.networkMonitor = null;
+    this.storageMonitor = null;
+    this.consoleMonitor = null;
+    this.people = new PeopleAPI(this);
+    this.autocaptureCleanup = null;
   }
   /**
    * Initialize the BentoLabs SDK
-   * @param apiKey - Your API key for authentication
-   * @param options - Optional configuration options
    */
   init(apiKey, options) {
-    var _a2;
-    if (this.isRecording || this.stopRecording) {
+    var _a2, _b, _c;
+    if (this.isRecording || this.stopRecordingFn) {
       this.stopRecordingInternal();
     }
     const defaultOptions = {
       endpoint: "https://api.bentolabs.ai",
       debug: false,
       batchSize: 100,
-      // Increased from 50 to reduce API calls
-      batchInterval: 3e4,
-      // 30 seconds (increased from 10s)
+      batchInterval: 5e3,
+      // 5 seconds (PostHog-style)
       enableRecording: true,
       maxRetries: 3,
-      baseRetryDelay: 1e3
-      // 1 second
+      baseRetryDelay: 1e3,
+      enableCompression: true,
+      // PostHog-like defaults
+      persistence: "localStorage+cookie",
+      respect_dnt: false,
+      autocapture: true,
+      capture_pageview: true,
+      capture_pageleave: true,
+      // Monitoring defaults
+      capture_network: true,
+      networkOptions: {
+        skipUrls: ["api.bentolabs.ai"],
+        captureHeaders: false,
+        captureBody: false,
+        maxBodySize: 5e3,
+        sampleRate: 1
+      },
+      capture_storage: true,
+      storageOptions: {
+        localStorage: true,
+        sessionStorage: true,
+        cookies: true,
+        sensitiveKeys: ["password", "token", "secret", "api_key", "apikey", "auth", "credential"]
+      },
+      capture_console: true,
+      consoleOptions: {
+        levels: ["log", "warn", "error", "info"],
+        maxLogs: 500,
+        maxPayloadSize: 5e3,
+        captureStackTrace: true
+      }
     };
     const mergedOptions = __spreadProps(__spreadValues(__spreadValues({}, defaultOptions), options), {
-      // Ensure debug is always a boolean
-      debug: (_a2 = options == null ? void 0 : options.debug) != null ? _a2 : defaultOptions.debug
+      networkOptions: __spreadValues(__spreadValues({}, defaultOptions.networkOptions), options == null ? void 0 : options.networkOptions),
+      storageOptions: __spreadValues(__spreadValues({}, defaultOptions.storageOptions), options == null ? void 0 : options.storageOptions),
+      consoleOptions: __spreadValues(__spreadValues({}, defaultOptions.consoleOptions), options == null ? void 0 : options.consoleOptions)
     });
     this.config = {
       apiKey,
@@ -12674,57 +13536,523 @@ var BentoLabsSDK = class {
       batchInterval: mergedOptions.batchInterval,
       enableRecording: mergedOptions.enableRecording,
       maxRetries: mergedOptions.maxRetries,
-      baseRetryDelay: mergedOptions.baseRetryDelay
+      baseRetryDelay: mergedOptions.baseRetryDelay,
+      enableCompression: (_a2 = mergedOptions.enableCompression) != null ? _a2 : true,
+      persistence: mergedOptions.persistence,
+      respect_dnt: mergedOptions.respect_dnt,
+      autocapture: mergedOptions.autocapture,
+      capture_pageview: mergedOptions.capture_pageview,
+      capture_pageleave: mergedOptions.capture_pageleave,
+      capture_network: mergedOptions.capture_network,
+      networkOptions: mergedOptions.networkOptions,
+      capture_storage: mergedOptions.capture_storage,
+      storageOptions: mergedOptions.storageOptions,
+      capture_console: mergedOptions.capture_console,
+      consoleOptions: mergedOptions.consoleOptions,
+      bootstrap: mergedOptions.bootstrap
     };
+    if (this.config.respect_dnt && this.isDNTEnabled()) {
+      if (this.config.debug) {
+        console.log("[BentoLabsSDK] Do Not Track is enabled, opting out");
+      }
+      this.optedOut = true;
+    }
+    this.persistence = new Persistence(this.config.persistence);
+    this.loadPersistedState();
+    if ((_b = this.config.bootstrap) == null ? void 0 : _b.distinctID) {
+      this.distinctId = this.config.bootstrap.distinctID;
+      this.identity.distinctId = this.config.bootstrap.distinctID;
+      this.identity.isIdentified = (_c = this.config.bootstrap.isIdentifiedID) != null ? _c : false;
+      this.persistence.set(PERSISTENCE_KEYS.DISTINCT_ID, this.distinctId);
+      if (this.identity.isIdentified) {
+        this.persistence.set(PERSISTENCE_KEYS.IS_IDENTIFIED, "true");
+      }
+    }
+    if (!this.distinctId) {
+      this.distinctId = this.generateAnonymousId();
+      this.persistence.set(PERSISTENCE_KEYS.DISTINCT_ID, this.distinctId);
+    }
     this.sessionId = this.generateSessionId();
+    this.initialized = true;
     if (this.config.debug) {
       console.log("[BentoLabsSDK] Initialized with config:", {
         apiKey: apiKey.substring(0, 8) + "...",
         endpoint: this.config.endpoint,
         debug: this.config.debug,
-        sessionId: this.sessionId
+        sessionId: this.sessionId,
+        distinctId: this.distinctId
       });
     }
     this.startRecording();
     this.startBatching();
+    if (this.config.autocapture) {
+      this.setupAutocapture();
+    }
+    if (this.config.capture_pageview) {
+      this.capture("$pageview", {
+        $current_url: typeof window !== "undefined" ? window.location.href : "",
+        $pathname: typeof window !== "undefined" ? window.location.pathname : "",
+        $referrer: typeof document !== "undefined" ? document.referrer : ""
+      });
+    }
+    if (this.config.capture_pageleave && typeof window !== "undefined") {
+      window.addEventListener("beforeunload", this.handlePageLeave.bind(this));
+    }
+    if (this.config.capture_network) {
+      this.startNetworkCapture();
+    }
+    if (this.config.capture_storage) {
+      this.startStorageCapture();
+    }
+    if (this.config.capture_console) {
+      this.startConsoleCapture();
+    }
   }
+  // ============================================================================
+  // Identity Methods
+  // ============================================================================
   /**
-   * Generate a unique session ID with 'sess_' prefix
+   * Identify a user with a distinct ID and optional properties
    */
-  generateSessionId() {
-    const uuid = this.generateUUID();
-    return `sess_${uuid}`;
+  identify(distinctId, properties) {
+    var _a2, _b, _c;
+    if (!this.initialized) {
+      console.warn("[BentoLabsSDK] Cannot identify: SDK not initialized");
+      return;
+    }
+    const previousId = this.distinctId;
+    this.distinctId = distinctId;
+    this.identity.distinctId = distinctId;
+    this.identity.isIdentified = true;
+    if (properties) {
+      this.identity.properties = __spreadValues(__spreadValues({}, this.identity.properties), properties);
+    }
+    (_a2 = this.persistence) == null ? void 0 : _a2.set(PERSISTENCE_KEYS.DISTINCT_ID, distinctId);
+    (_b = this.persistence) == null ? void 0 : _b.set(PERSISTENCE_KEYS.IS_IDENTIFIED, "true");
+    if (properties) {
+      (_c = this.persistence) == null ? void 0 : _c.set(PERSISTENCE_KEYS.USER_PROPERTIES, JSON.stringify(this.identity.properties));
+    }
+    this.capture("$identify", __spreadValues({
+      $anon_distinct_id: previousId
+    }, properties));
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Identified user:", distinctId);
+    }
   }
   /**
-   * Generate a simple UUID v4
+   * Reset the user to an anonymous state
    */
-  generateUUID() {
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
-      /[xy]/g,
-      function(c) {
-        const r = Math.random() * 16 | 0;
-        const v = c === "x" ? r : r & 3 | 8;
-        return v.toString(16);
+  reset() {
+    var _a2, _b;
+    if (!this.initialized) return;
+    this.distinctId = this.generateAnonymousId();
+    this.identity = {
+      distinctId: null,
+      properties: {},
+      isIdentified: false
+    };
+    this.superProperties = {};
+    (_a2 = this.persistence) == null ? void 0 : _a2.clear();
+    (_b = this.persistence) == null ? void 0 : _b.set(PERSISTENCE_KEYS.DISTINCT_ID, this.distinctId);
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Reset to anonymous:", this.distinctId);
+    }
+  }
+  /**
+   * Get the current distinct ID
+   */
+  getDistinctId() {
+    return this.distinctId;
+  }
+  // ============================================================================
+  // Super Properties Methods
+  // ============================================================================
+  /**
+   * Register super properties to be sent with every event
+   */
+  register(properties) {
+    var _a2;
+    this.superProperties = __spreadValues(__spreadValues({}, this.superProperties), properties);
+    (_a2 = this.persistence) == null ? void 0 : _a2.set(PERSISTENCE_KEYS.SUPER_PROPERTIES, JSON.stringify(this.superProperties));
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Registered super properties:", properties);
+    }
+  }
+  /**
+   * Register super properties only if they haven't been set
+   */
+  registerOnce(properties) {
+    const newProps = {};
+    for (const [key, value] of Object.entries(properties)) {
+      if (!(key in this.superProperties)) {
+        newProps[key] = value;
       }
-    );
+    }
+    if (Object.keys(newProps).length > 0) {
+      this.register(newProps);
+    }
   }
   /**
-   * Start recording user interactions
+   * Remove a super property
    */
-  startRecording() {
-    if (!this.config.enableRecording) {
+  unregister(propertyName) {
+    var _a2;
+    delete this.superProperties[propertyName];
+    (_a2 = this.persistence) == null ? void 0 : _a2.set(PERSISTENCE_KEYS.SUPER_PROPERTIES, JSON.stringify(this.superProperties));
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Unregistered super property:", propertyName);
+    }
+  }
+  // ============================================================================
+  // Event Capture
+  // ============================================================================
+  /**
+   * Capture an event
+   */
+  capture(eventName, properties) {
+    if (!this.initialized) {
+      console.warn("[BentoLabsSDK] Cannot capture event: SDK not initialized");
+      return;
+    }
+    if (this.optedOut) {
       if (this.config.debug) {
-        console.log("[BentoLabsSDK] Recording disabled in configuration");
+        console.log("[BentoLabsSDK] Event not captured (opted out):", eventName);
       }
       return;
     }
+    const event = {
+      event: eventName,
+      properties: __spreadProps(__spreadValues(__spreadValues({}, this.superProperties), properties), {
+        $current_url: typeof window !== "undefined" ? window.location.href : "",
+        $pathname: typeof window !== "undefined" ? window.location.pathname : ""
+      }),
+      $timestamp: Date.now(),
+      $session_id: this.sessionId,
+      $distinct_id: this.distinctId
+    };
+    this.addEvent({
+      timestamp: event.$timestamp,
+      type: `capture:${eventName}`,
+      data: event,
+      sessionId: this.sessionId
+    });
     if (this.config.debug) {
-      console.log(
-        "[BentoLabsSDK] Starting recording for session:",
-        this.sessionId
-      );
+      console.log("[BentoLabsSDK] Captured event:", eventName, properties);
     }
-    try {
+  }
+  /**
+   * Track a custom event (legacy method, delegates to capture)
+   */
+  trackCustomEvent(eventName, data) {
+    if (!this.sessionId) {
+      console.warn("[BentoLabsSDK] Cannot track event: SDK not initialized");
+      return;
+    }
+    this.capture(`custom:${eventName}`, data);
+  }
+  // ============================================================================
+  // Opt-in/Opt-out
+  // ============================================================================
+  /**
+   * Opt out of tracking
+   */
+  opt_out_capturing() {
+    var _a2;
+    this.optedOut = true;
+    (_a2 = this.persistence) == null ? void 0 : _a2.set(PERSISTENCE_KEYS.OPTED_OUT, "true");
+    if (this.isRecording) {
+      this.stopRecordingInternal();
+    }
+    this.stopNetworkCapture();
+    this.stopStorageCapture();
+    this.stopConsoleCapture();
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Opted out of capturing");
+    }
+  }
+  /**
+   * Opt back into tracking
+   */
+  opt_in_capturing() {
+    var _a2;
+    this.optedOut = false;
+    (_a2 = this.persistence) == null ? void 0 : _a2.remove(PERSISTENCE_KEYS.OPTED_OUT);
+    if (this.initialized && this.config.enableRecording) {
+      this.startRecording();
+    }
+    if (this.config.capture_network) {
+      this.startNetworkCapture();
+    }
+    if (this.config.capture_storage) {
+      this.startStorageCapture();
+    }
+    if (this.config.capture_console) {
+      this.startConsoleCapture();
+    }
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Opted back into capturing");
+    }
+  }
+  /**
+   * Check if user has opted out
+   */
+  has_opted_out_capturing() {
+    return this.optedOut;
+  }
+  /**
+   * Check if user has opted in (not opted out)
+   */
+  has_opted_in_capturing() {
+    return !this.optedOut;
+  }
+  // ============================================================================
+  // Monitoring Control
+  // ============================================================================
+  /**
+   * Start network request monitoring
+   */
+  startNetworkCapture() {
+    if (this.networkMonitor) return;
+    this.networkMonitor = new NetworkMonitor(this.config.networkOptions, (log) => {
+      if (!this.optedOut) {
+        this.capture("$network_request", log);
+      }
+    });
+    this.networkMonitor.start();
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Network capture started");
+    }
+  }
+  /**
+   * Stop network request monitoring
+   */
+  stopNetworkCapture() {
+    if (this.networkMonitor) {
+      this.networkMonitor.stop();
+      this.networkMonitor = null;
+      if (this.config.debug) {
+        console.log("[BentoLabsSDK] Network capture stopped");
+      }
+    }
+  }
+  /**
+   * Start storage monitoring
+   */
+  startStorageCapture() {
+    if (this.storageMonitor) return;
+    this.storageMonitor = new StorageMonitor(this.config.storageOptions, (log) => {
+      if (!this.optedOut) {
+        this.capture("$storage_event", log);
+      }
+    });
+    this.storageMonitor.start();
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Storage capture started");
+    }
+  }
+  /**
+   * Stop storage monitoring
+   */
+  stopStorageCapture() {
+    if (this.storageMonitor) {
+      this.storageMonitor.stop();
+      this.storageMonitor = null;
+      if (this.config.debug) {
+        console.log("[BentoLabsSDK] Storage capture stopped");
+      }
+    }
+  }
+  /**
+   * Start console monitoring
+   */
+  startConsoleCapture() {
+    if (this.consoleMonitor) return;
+    this.consoleMonitor = new ConsoleMonitor(this.config.consoleOptions, (log) => {
+      if (!this.optedOut) {
+        this.capture("$console_log", log);
+      }
+    });
+    this.consoleMonitor.start();
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Console capture started");
+    }
+  }
+  /**
+   * Stop console monitoring
+   */
+  stopConsoleCapture() {
+    if (this.consoleMonitor) {
+      this.consoleMonitor.stop();
+      this.consoleMonitor = null;
+      if (this.config.debug) {
+        console.log("[BentoLabsSDK] Console capture stopped");
+      }
+    }
+  }
+  /**
+   * Get network logs
+   */
+  getNetworkLogs() {
+    var _a2;
+    return ((_a2 = this.networkMonitor) == null ? void 0 : _a2.getLogs()) || [];
+  }
+  /**
+   * Get storage logs
+   */
+  getStorageLogs() {
+    var _a2;
+    return ((_a2 = this.storageMonitor) == null ? void 0 : _a2.getLogs()) || [];
+  }
+  /**
+   * Get console logs
+   */
+  getConsoleLogs() {
+    var _a2;
+    return ((_a2 = this.consoleMonitor) == null ? void 0 : _a2.getLogs()) || [];
+  }
+  // ============================================================================
+  // Existing Public Methods (Preserved)
+  // ============================================================================
+  /**
+   * Stop recording and clean up resources
+   */
+  stop() {
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Stopping recording and batching");
+    }
+    this.stopRecordingInternal();
+    this.stopNetworkCapture();
+    this.stopStorageCapture();
+    this.stopConsoleCapture();
+    if (this.events.length > 0) {
+      this.sendBatch();
+    }
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Stopped successfully");
+    }
+  }
+  /**
+   * Get current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Check if recording is active
+   */
+  isRecordingActive() {
+    return this.isRecording;
+  }
+  /**
+   * Get current configuration (without exposing sensitive data)
+   */
+  getConfig() {
+    return {
+      apiKey: this.config.apiKey ? this.config.apiKey.substring(0, 8) + "..." : "",
+      endpoint: this.config.endpoint,
+      debug: this.config.debug,
+      batchSize: this.config.batchSize,
+      batchInterval: this.config.batchInterval,
+      enableRecording: this.config.enableRecording,
+      maxRetries: this.config.maxRetries,
+      baseRetryDelay: this.config.baseRetryDelay,
+      enableCompression: this.config.enableCompression,
+      persistence: this.config.persistence,
+      respect_dnt: this.config.respect_dnt,
+      autocapture: this.config.autocapture,
+      capture_pageview: this.config.capture_pageview,
+      capture_pageleave: this.config.capture_pageleave,
+      capture_network: this.config.capture_network,
+      networkOptions: this.config.networkOptions,
+      capture_storage: this.config.capture_storage,
+      storageOptions: this.config.storageOptions,
+      capture_console: this.config.capture_console,
+      consoleOptions: this.config.consoleOptions
+    };
+  }
+  /**
+   * Get current event queue length
+   */
+  getEventQueueLength() {
+    return this.events.length;
+  }
+  /**
+   * Manually trigger a batch send
+   */
+  async flushEvents() {
+    await this.sendBatch();
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  generateSessionId() {
+    const uuid = this.generateUUID();
+    return `sess_${uuid}`;
+  }
+  generateAnonymousId() {
+    const uuid = this.generateUUID();
+    return `anon_${uuid}`;
+  }
+  generateUUID() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  isDNTEnabled() {
+    if (typeof navigator === "undefined") return false;
+    return navigator.doNotTrack === "1" || navigator.doNotTrack === "yes";
+  }
+  loadPersistedState() {
+    if (!this.persistence) return;
+    const storedDistinctId = this.persistence.get(PERSISTENCE_KEYS.DISTINCT_ID);
+    if (storedDistinctId) {
+      this.distinctId = storedDistinctId;
+      this.identity.distinctId = storedDistinctId;
+    }
+    const isIdentified = this.persistence.get(PERSISTENCE_KEYS.IS_IDENTIFIED);
+    if (isIdentified === "true") {
+      this.identity.isIdentified = true;
+    }
+    const storedSuperProps = this.persistence.get(PERSISTENCE_KEYS.SUPER_PROPERTIES);
+    if (storedSuperProps) {
+      try {
+        this.superProperties = JSON.parse(storedSuperProps);
+      } catch (e) {
+        this.superProperties = {};
+      }
+    }
+    const storedUserProps = this.persistence.get(PERSISTENCE_KEYS.USER_PROPERTIES);
+    if (storedUserProps) {
+      try {
+        this.identity.properties = JSON.parse(storedUserProps);
+      } catch (e) {
+        this.identity.properties = {};
+      }
+    }
+    const optedOut = this.persistence.get(PERSISTENCE_KEYS.OPTED_OUT);
+    if (optedOut === "true") {
+      this.optedOut = true;
+    }
+  }
+  startRecording() {
+    if (!this.config.enableRecording) {
+      if (this.config.debug) {
+        console.log("[BentoLabsSDK] Recording disabled in configuration");
+      }
+      return;
+    }
+    if (this.optedOut) {
+      if (this.config.debug) {
+        console.log("[BentoLabsSDK] Recording disabled (opted out)");
+      }
+      return;
+    }
+    if (this.config.debug) {
+      console.log("[BentoLabsSDK] Starting recording for session:", this.sessionId);
+    }
+    try {
       if (this.config.debug) {
         console.log("[BentoLabsSDK] Calling rrweb record()...");
       }
@@ -12743,7 +14071,6 @@ var BentoLabsSDK = class {
         recordCanvas: true,
         collectFonts: true,
         plugins: [],
-        // Enable element context capture for rich metadata on interactions
         captureElementContext: true,
         elementContextOptions: {
           maxTextLength: 500,
@@ -12751,33 +14078,28 @@ var BentoLabsSDK = class {
           outerHTMLDepth: 2,
           includeInputValues: true
         },
-        // Mask password inputs for security
         maskInputOptions: {
           password: true
         },
-        // Sampling and throttling to reduce event volume
         sampling: {
           mousemove: true,
-          // Sample mouse movements
           mouseInteraction: { click: false, dblclick: false },
-          // Capture all clicks
           scroll: 150,
-          // Throttle scroll events to 150ms
           input: "last"
-          // Only record final input value
         },
         checkoutEveryNms: 5 * 60 * 1e3
-        // Take full snapshot every 5 minutes
       });
       if (typeof stopFn === "function") {
-        this.stopRecording = stopFn;
+        this.stopRecordingFn = stopFn;
         this.isRecording = true;
         if (this.config.debug) {
           console.log("[BentoLabsSDK] Recording started successfully");
         }
       } else {
-        console.error("[BentoLabsSDK] rrweb record() did not return a stop function. Recording may not have started properly.");
-        this.stopRecording = null;
+        console.error(
+          "[BentoLabsSDK] rrweb record() did not return a stop function. Recording may not have started properly."
+        );
+        this.stopRecordingFn = null;
         this.isRecording = false;
       }
     } catch (error) {
@@ -12785,9 +14107,6 @@ var BentoLabsSDK = class {
       this.isRecording = false;
     }
   }
-  /**
-   * Start batching events for transmission
-   */
   startBatching() {
     if (this.config.debug) {
       console.log("[BentoLabsSDK] Starting event batching");
@@ -12799,32 +14118,29 @@ var BentoLabsSDK = class {
       this.sendBatch();
     }, this.config.batchInterval);
     if (this.config.debug) {
-      console.log(
-        `[BentoLabsSDK] Batch timer set for ${this.config.batchInterval}ms intervals`
-      );
+      console.log(`[BentoLabsSDK] Batch timer set for ${this.config.batchInterval}ms intervals`);
     }
   }
-  /**
-   * Add an event to the events array
-   */
   addEvent(event) {
+    if (this.optedOut) return;
     this.events.push(event);
     if (this.config.debug) {
       console.log("[BentoLabsSDK] Event added:", event.type);
     }
-    if (this.events.length >= this.config.batchSize) {
+    if (this.events.length >= this.config.batchSize && !this.isSending) {
       if (this.config.debug) {
-        console.log(
-          `[BentoLabsSDK] Batch size limit reached (${this.config.batchSize}), sending batch`
-        );
+        console.log(`[BentoLabsSDK] Batch size limit reached (${this.config.batchSize}), sending batch`);
       }
       this.sendBatch();
     }
   }
-  /**
-   * Send batched events to the API with exponential backoff retry
-   */
   async sendBatch() {
+    if (this.isSending) {
+      if (this.config.debug) {
+        console.log("[BentoLabsSDK] Already sending, skipping batch");
+      }
+      return;
+    }
     const now = Date.now();
     const readyEvents = this.events.filter((event) => {
       if ("nextRetryTime" in event) {
@@ -12835,28 +14151,67 @@ var BentoLabsSDK = class {
     if (readyEvents.length === 0) {
       return;
     }
+    this.isSending = true;
     this.events = this.events.filter((event) => !readyEvents.includes(event));
     const payload = {
       sessionId: this.sessionId,
       events: readyEvents,
       timestamp: now,
       userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "Unknown",
-      url: typeof window !== "undefined" ? window.location.href : "Unknown"
+      url: typeof window !== "undefined" ? window.location.href : "Unknown",
+      distinctId: this.distinctId
     };
     if (this.config.debug) {
-      console.log(
-        `[BentoLabsSDK] Sending batch with ${readyEvents.length} events`
-      );
+      console.log(`[BentoLabsSDK] Sending batch with ${readyEvents.length} events`);
     }
     try {
+      const jsonPayload = JSON.stringify(payload);
+      let body = jsonPayload;
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "X-Session-ID": this.sessionId
+      };
+      if (this.config.enableCompression && typeof CompressionStream !== "undefined") {
+        try {
+          const encoder = new TextEncoder();
+          const data = encoder.encode(jsonPayload);
+          const cs = new CompressionStream("gzip");
+          const writer = cs.writable.getWriter();
+          writer.write(data);
+          writer.close();
+          const compressedChunks = [];
+          const reader = cs.readable.getReader();
+          let result2 = await reader.read();
+          while (!result2.done) {
+            compressedChunks.push(result2.value);
+            result2 = await reader.read();
+          }
+          const totalLength = compressedChunks.reduce((acc, chunk) => acc + chunk.length, 0);
+          const compressedData = new Uint8Array(totalLength);
+          let offset = 0;
+          for (const chunk of compressedChunks) {
+            compressedData.set(chunk, offset);
+            offset += chunk.length;
+          }
+          body = new Blob([compressedData], { type: "application/json" });
+          headers["Content-Encoding"] = "gzip";
+          if (this.config.debug) {
+            const ratio = ((1 - compressedData.length / data.length) * 100).toFixed(1);
+            console.log(
+              `[BentoLabsSDK] Compressed payload: ${data.length} -> ${compressedData.length} bytes (${ratio}% reduction)`
+            );
+          }
+        } catch (compressionError) {
+          if (this.config.debug) {
+            console.warn("[BentoLabsSDK] Compression failed, sending uncompressed:", compressionError);
+          }
+        }
+      }
       const response = await fetch(`${this.config.endpoint}/events/`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.config.apiKey}`,
-          "X-Session-ID": this.sessionId
-        },
-        body: JSON.stringify(payload)
+        headers,
+        body
       });
       if (!response.ok) {
         throw new Error(`HTTP error! status: ${response.status}`);
@@ -12865,7 +14220,9 @@ var BentoLabsSDK = class {
         console.log("[BentoLabsSDK] Batch sent successfully");
       }
     } catch (error) {
-      console.error("[BentoLabsSDK] Failed to send batch:", error);
+      if (this.config.debug) {
+        console.error("[BentoLabsSDK] Failed to send batch:", error);
+      }
       const retryableEvents = readyEvents.map((event) => {
         const retryCount = "retryCount" in event ? event.retryCount + 1 : 1;
         const delay = this.config.baseRetryDelay * Math.pow(2, retryCount - 1);
@@ -12874,43 +14231,33 @@ var BentoLabsSDK = class {
           nextRetryTime: now + delay
         });
       });
-      const eventsToRetry = retryableEvents.filter(
-        (event) => event.retryCount <= this.config.maxRetries
-      );
+      const eventsToRetry = retryableEvents.filter((event) => event.retryCount <= this.config.maxRetries);
       const droppedEvents = retryableEvents.length - eventsToRetry.length;
       if (droppedEvents > 0 && this.config.debug) {
-        console.log(
-          `[BentoLabsSDK] Dropped ${droppedEvents} events after max retries`
-        );
+        console.log(`[BentoLabsSDK] Dropped ${droppedEvents} events after max retries`);
       }
-      this.events.unshift(...eventsToRetry);
-      if (this.config.debug && eventsToRetry.length > 0) {
-        const nextRetryIn = Math.min(...eventsToRetry.map((e) => e.nextRetryTime)) - now;
-        console.log(
-          `[BentoLabsSDK] ${eventsToRetry.length} events re-queued for retry in ${nextRetryIn}ms`
-        );
+      if (eventsToRetry.length > 0) {
+        this.events.unshift(...eventsToRetry);
+        if (this.config.debug) {
+          const nextRetryIn = Math.min(...eventsToRetry.map((e) => e.nextRetryTime)) - now;
+          console.log(`[BentoLabsSDK] ${eventsToRetry.length} events re-queued for retry in ${nextRetryIn}ms`);
+        }
       }
-      this.scheduleRetry();
+    } finally {
+      this.isSending = false;
     }
   }
-  /**
-   * Schedule retry attempts for failed events
-   */
   scheduleRetry() {
     if (this.retryTimer) {
       clearTimeout(this.retryTimer);
       this.retryTimer = null;
     }
     const now = Date.now();
-    const retryableEvents = this.events.filter(
-      (event) => "nextRetryTime" in event
-    );
+    const retryableEvents = this.events.filter((event) => "nextRetryTime" in event);
     if (retryableEvents.length === 0) {
       return;
     }
-    const nextRetryTime = Math.min(
-      ...retryableEvents.map((e) => e.nextRetryTime)
-    );
+    const nextRetryTime = Math.min(...retryableEvents.map((e) => e.nextRetryTime));
     const delay = Math.max(0, nextRetryTime - now);
     if (this.config.debug) {
       console.log(`[BentoLabsSDK] Scheduling retry in ${delay}ms`);
@@ -12919,13 +14266,10 @@ var BentoLabsSDK = class {
       this.sendBatch();
     }, delay);
   }
-  /**
-   * Internal method to stop recording without logging (used during re-init)
-   */
   stopRecordingInternal() {
-    if (this.stopRecording) {
-      this.stopRecording();
-      this.stopRecording = null;
+    if (this.stopRecordingFn) {
+      this.stopRecordingFn();
+      this.stopRecordingFn = null;
     }
     if (this.batchTimer) {
       clearInterval(this.batchTimer);
@@ -12935,86 +14279,115 @@ var BentoLabsSDK = class {
       clearTimeout(this.retryTimer);
       this.retryTimer = null;
     }
+    if (this.autocaptureCleanup) {
+      this.autocaptureCleanup();
+      this.autocaptureCleanup = null;
+    }
     this.isRecording = false;
   }
-  /**
-   * Stop recording and clean up resources
-   */
-  stop() {
-    if (this.config.debug) {
-      console.log("[BentoLabsSDK] Stopping recording and batching");
-    }
-    this.stopRecordingInternal();
-    if (this.events.length > 0) {
-      this.sendBatch();
-    }
+  setupAutocapture() {
+    if (typeof document === "undefined") return;
+    const handleClick = (e) => {
+      var _a2;
+      const target = e.target;
+      if (!target) return;
+      const tagName = target.tagName.toLowerCase();
+      const allowedTags = ["a", "button", "input", "select", "textarea"];
+      const isAllowed = allowedTags.includes(tagName) || target.getAttribute("role") === "button" || target.hasAttribute("data-bento-capture");
+      if (!isAllowed) return;
+      let selector = "";
+      try {
+        selector = generateSelectorFromElement(target);
+      } catch (e2) {
+        selector = "";
+      }
+      this.capture("$autocapture", {
+        $event_type: "click",
+        $element_tag: tagName,
+        $element_text: ((_a2 = target.textContent) == null ? void 0 : _a2.slice(0, 100)) || "",
+        $element_classes: target.className || "",
+        $element_id: target.id || "",
+        $bento_selector: selector
+      });
+    };
+    const handleChange = (e) => {
+      const target = e.target;
+      if (!target) return;
+      const tagName = target.tagName.toLowerCase();
+      if (!["input", "select", "textarea"].includes(tagName)) return;
+      if (target.type === "password") return;
+      let selector = "";
+      try {
+        selector = generateSelectorFromElement(target);
+      } catch (e2) {
+        selector = "";
+      }
+      this.capture("$autocapture", {
+        $event_type: "change",
+        $element_tag: tagName,
+        $element_type: target.type || "",
+        $element_name: target.name || "",
+        $element_id: target.id || "",
+        $bento_selector: selector
+        // Don't capture actual value for privacy
+      });
+    };
+    const handleSubmit = (e) => {
+      const target = e.target;
+      if (!target || target.tagName.toLowerCase() !== "form") return;
+      let selector = "";
+      try {
+        selector = generateSelectorFromElement(target);
+      } catch (e2) {
+        selector = "";
+      }
+      this.capture("$autocapture", {
+        $event_type: "submit",
+        $element_tag: "form",
+        $form_name: target.name || "",
+        $form_id: target.id || "",
+        $form_action: target.action || "",
+        $bento_selector: selector
+      });
+    };
+    document.addEventListener("click", handleClick, true);
+    document.addEventListener("change", handleChange, true);
+    document.addEventListener("submit", handleSubmit, true);
+    this.autocaptureCleanup = () => {
+      document.removeEventListener("click", handleClick, true);
+      document.removeEventListener("change", handleChange, true);
+      document.removeEventListener("submit", handleSubmit, true);
+    };
     if (this.config.debug) {
-      console.log("[BentoLabsSDK] Stopped successfully");
+      console.log("[BentoLabsSDK] Autocapture setup complete");
     }
   }
-  /**
-   * Get current session ID
-   */
-  getSessionId() {
-    return this.sessionId;
-  }
-  /**
-   * Check if recording is active
-   */
-  isRecordingActive() {
-    return this.isRecording;
-  }
-  /**
-   * Get current configuration (without exposing sensitive data)
-   */
-  getConfig() {
-    return {
-      apiKey: this.config.apiKey ? this.config.apiKey.substring(0, 8) + "..." : "",
-      endpoint: this.config.endpoint,
-      debug: this.config.debug,
-      batchSize: this.config.batchSize,
-      batchInterval: this.config.batchInterval,
-      enableRecording: this.config.enableRecording,
-      maxRetries: this.config.maxRetries,
-      baseRetryDelay: this.config.baseRetryDelay
-    };
-  }
-  /**
-   * Get current event queue length
-   */
-  getEventQueueLength() {
-    return this.events.length;
-  }
-  /**
-   * Manually trigger a batch send
-   */
-  async flushEvents() {
-    await this.sendBatch();
-  }
-  /**
-   * Track a custom event with custom data
-   * @param eventName - Name of the custom event
-   * @param data - Custom event data (will be JSON stringified)
-   */
-  trackCustomEvent(eventName, data) {
-    if (!this.sessionId) {
-      console.warn("[BentoLabsSDK] Cannot track event: SDK not initialized");
-      return;
-    }
-    this.addEvent({
-      timestamp: Date.now(),
-      type: `custom:${eventName}`,
-      data: data || {},
-      sessionId: this.sessionId
+  handlePageLeave() {
+    this.capture("$pageleave", {
+      $current_url: typeof window !== "undefined" ? window.location.href : "",
+      $pathname: typeof window !== "undefined" ? window.location.pathname : ""
     });
-    if (this.config.debug) {
-      console.log(`[BentoLabsSDK] Custom event tracked: ${eventName}`, data);
+    if (this.events.length > 0 && typeof navigator !== "undefined" && navigator.sendBeacon) {
+      const payload = {
+        sessionId: this.sessionId,
+        events: this.events,
+        timestamp: Date.now(),
+        userAgent: navigator.userAgent,
+        url: window.location.href,
+        distinctId: this.distinctId
+      };
+      navigator.sendBeacon(
+        `${this.config.endpoint}/events/`,
+        new Blob([JSON.stringify(payload)], { type: "application/json" })
+      );
+      this.events = [];
     }
   }
 };
 var sdk = new BentoLabsSDK();
 if (typeof window !== "undefined") {
-  window.BentoLabsSDK = __spreadProps(__spreadValues({}, sdk), {
+  window.BentoLabsSDK = {
+    // Core methods
     init: sdk.init.bind(sdk),
     stop: sdk.stop.bind(sdk),
     getSessionId: sdk.getSessionId.bind(sdk),
@@ -13023,8 +14396,34 @@ if (typeof window !== "undefined") {
     getEventQueueLength: sdk.getEventQueueLength.bind(sdk),
     flushEvents: sdk.flushEvents.bind(sdk),
     trackCustomEvent: sdk.trackCustomEvent.bind(sdk),
-    generateSelector
-  });
+    // Selector generation
+    generateSelector,
+    generateSelectorFromElement,
+    generateSelectorFromHTML,
+    // PostHog-like methods
+    capture: sdk.capture.bind(sdk),
+    identify: sdk.identify.bind(sdk),
+    reset: sdk.reset.bind(sdk),
+    getDistinctId: sdk.getDistinctId.bind(sdk),
+    register: sdk.register.bind(sdk),
+    registerOnce: sdk.registerOnce.bind(sdk),
+    unregister: sdk.unregister.bind(sdk),
+    opt_out_capturing: sdk.opt_out_capturing.bind(sdk),
+    opt_in_capturing: sdk.opt_in_capturing.bind(sdk),
+    has_opted_out_capturing: sdk.has_opted_out_capturing.bind(sdk),
+    has_opted_in_capturing: sdk.has_opted_in_capturing.bind(sdk),
+    people: sdk.people,
+    // Monitoring control
+    startNetworkCapture: sdk.startNetworkCapture.bind(sdk),
+    stopNetworkCapture: sdk.stopNetworkCapture.bind(sdk),
+    startStorageCapture: sdk.startStorageCapture.bind(sdk),
+    stopStorageCapture: sdk.stopStorageCapture.bind(sdk),
+    startConsoleCapture: sdk.startConsoleCapture.bind(sdk),
+    stopConsoleCapture: sdk.stopConsoleCapture.bind(sdk),
+    getNetworkLogs: sdk.getNetworkLogs.bind(sdk),
+    getStorageLogs: sdk.getStorageLogs.bind(sdk),
+    getConsoleLogs: sdk.getConsoleLogs.bind(sdk)
+  };
 }
 var index_default = sdk;
 /*! Bundled license information: