@tell-rs/browser 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1291 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ClosedError: () => ClosedError,
+  ConfigurationError: () => ConfigurationError,
+  Events: () => Events,
+  NetworkError: () => NetworkError,
+  SerializationError: () => SerializationError,
+  TellError: () => TellError,
+  ValidationError: () => ValidationError,
+  default: () => index_default,
+  development: () => development,
+  production: () => production,
+  tell: () => tell
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../core/src/constants.ts
+var Events = {
+  // User Lifecycle
+  UserSignedUp: "User Signed Up",
+  UserSignedIn: "User Signed In",
+  UserSignedOut: "User Signed Out",
+  UserInvited: "User Invited",
+  UserOnboarded: "User Onboarded",
+  AuthenticationFailed: "Authentication Failed",
+  PasswordReset: "Password Reset",
+  TwoFactorEnabled: "Two Factor Enabled",
+  TwoFactorDisabled: "Two Factor Disabled",
+  // Revenue & Billing
+  OrderCompleted: "Order Completed",
+  OrderRefunded: "Order Refunded",
+  OrderCanceled: "Order Canceled",
+  PaymentFailed: "Payment Failed",
+  PaymentMethodAdded: "Payment Method Added",
+  PaymentMethodUpdated: "Payment Method Updated",
+  PaymentMethodRemoved: "Payment Method Removed",
+  // Subscription
+  SubscriptionStarted: "Subscription Started",
+  SubscriptionRenewed: "Subscription Renewed",
+  SubscriptionPaused: "Subscription Paused",
+  SubscriptionResumed: "Subscription Resumed",
+  SubscriptionChanged: "Subscription Changed",
+  SubscriptionCanceled: "Subscription Canceled",
+  // Trial
+  TrialStarted: "Trial Started",
+  TrialEndingSoon: "Trial Ending Soon",
+  TrialEnded: "Trial Ended",
+  TrialConverted: "Trial Converted",
+  // Shopping
+  CartViewed: "Cart Viewed",
+  CartUpdated: "Cart Updated",
+  CartAbandoned: "Cart Abandoned",
+  CheckoutStarted: "Checkout Started",
+  CheckoutCompleted: "Checkout Completed",
+  // Engagement
+  PageViewed: "Page Viewed",
+  FeatureUsed: "Feature Used",
+  SearchPerformed: "Search Performed",
+  FileUploaded: "File Uploaded",
+  NotificationSent: "Notification Sent",
+  NotificationClicked: "Notification Clicked",
+  // Communication
+  EmailSent: "Email Sent",
+  EmailOpened: "Email Opened",
+  EmailClicked: "Email Clicked",
+  EmailBounced: "Email Bounced",
+  EmailUnsubscribed: "Email Unsubscribed",
+  SupportTicketCreated: "Support Ticket Created",
+  SupportTicketResolved: "Support Ticket Resolved"
+};
+
+// ../core/src/errors.ts
+var TellError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TellError";
+  }
+};
+var ConfigurationError = class extends TellError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var ValidationError = class extends TellError {
+  field;
+  constructor(field, message) {
+    super(`${field}: ${message}`);
+    this.name = "ValidationError";
+    this.field = field;
+  }
+};
+var NetworkError = class extends TellError {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "NetworkError";
+    this.statusCode = statusCode;
+  }
+};
+var ClosedError = class extends TellError {
+  constructor() {
+    super("Client is closed");
+    this.name = "ClosedError";
+  }
+};
+var SerializationError = class extends TellError {
+  constructor(message) {
+    super(message);
+    this.name = "SerializationError";
+  }
+};
+
+// ../core/src/validation.ts
+var HEX_RE = /^[0-9a-fA-F]{32}$/;
+var MAX_EVENT_NAME = 256;
+var MAX_LOG_MESSAGE = 65536;
+function validateApiKey(key) {
+  if (!key) {
+    throw new ConfigurationError("apiKey is required");
+  }
+  if (!HEX_RE.test(key)) {
+    throw new ConfigurationError(
+      "apiKey must be exactly 32 hex characters"
+    );
+  }
+}
+function validateEventName(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new ValidationError("eventName", "must be a non-empty string");
+  }
+  if (name.length > MAX_EVENT_NAME) {
+    throw new ValidationError(
+      "eventName",
+      `must be at most ${MAX_EVENT_NAME} characters, got ${name.length}`
+    );
+  }
+}
+function validateLogMessage(message) {
+  if (typeof message !== "string" || message.length === 0) {
+    throw new ValidationError("message", "must be a non-empty string");
+  }
+  if (message.length > MAX_LOG_MESSAGE) {
+    throw new ValidationError(
+      "message",
+      `must be at most ${MAX_LOG_MESSAGE} characters, got ${message.length}`
+    );
+  }
+}
+function validateUserId(id) {
+  if (typeof id !== "string" || id.length === 0) {
+    throw new ValidationError("userId", "must be a non-empty string");
+  }
+}
+
+// ../core/src/batcher.ts
+var Batcher = class {
+  queue = [];
+  timer = null;
+  closed = false;
+  flushing = null;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.timer = setInterval(() => {
+      if (this.queue.length > 0) {
+        this.flush().catch(() => {
+        });
+      }
+    }, config.interval);
+    if (this.timer && typeof this.timer.unref === "function") {
+      this.timer.unref();
+    }
+  }
+  add(item) {
+    if (this.closed) return;
+    if (this.queue.length >= this.config.maxQueueSize) {
+      this.queue.shift();
+      if (this.config.onOverflow) {
+        this.config.onOverflow();
+      }
+    }
+    this.queue.push(item);
+    if (this.queue.length >= this.config.size) {
+      this.flush().catch(() => {
+      });
+    }
+  }
+  async flush() {
+    if (this.flushing) {
+      return this.flushing;
+    }
+    this.flushing = this.doFlush();
+    try {
+      await this.flushing;
+    } finally {
+      this.flushing = null;
+    }
+  }
+  async close() {
+    this.closed = true;
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  drain() {
+    const items = this.queue;
+    this.queue = [];
+    return items;
+  }
+  halveBatchSize() {
+    this.config.size = Math.max(1, Math.floor(this.config.size / 2));
+  }
+  async doFlush() {
+    while (this.queue.length > 0) {
+      const batch = this.queue.slice(0, this.config.size);
+      try {
+        await this.config.send(batch);
+        this.queue.splice(0, batch.length);
+      } catch {
+        return;
+      }
+    }
+  }
+};
+
+// ../core/src/before-send.ts
+function runBeforeSend(item, fns) {
+  const pipeline = Array.isArray(fns) ? fns : [fns];
+  let current = item;
+  for (const fn of pipeline) {
+    if (current === null) return null;
+    current = fn(current);
+  }
+  return current;
+}
+
+// src/config.ts
+var DEFAULTS = {
+  endpoint: "https://collect.tell.app",
+  batchSize: 20,
+  flushInterval: 5e3,
+  maxRetries: 5,
+  closeTimeout: 5e3,
+  networkTimeout: 1e4,
+  logLevel: "error",
+  source: "browser",
+  disabled: false,
+  maxQueueSize: 1e3,
+  sessionTimeout: 18e5,
+  // 30 min
+  persistence: "localStorage",
+  respectDoNotTrack: false,
+  botDetection: true,
+  captureErrors: false
+};
+function resolveConfig(options) {
+  return { ...DEFAULTS, ...options };
+}
+function development(overrides) {
+  return {
+    endpoint: "http://localhost:8080",
+    batchSize: 5,
+    flushInterval: 2e3,
+    logLevel: "debug",
+    ...overrides
+  };
+}
+function production(overrides) {
+  return {
+    logLevel: "error",
+    ...overrides
+  };
+}
+
+// src/persistence.ts
+var STORAGE_KEYS = {
+  DEVICE_ID: "tell_device_id",
+  USER_ID: "tell_user_id",
+  OPT_OUT: "tell_opt_out",
+  SUPER_PROPS: "tell_super_props"
+};
+var LocalStorageStorage = class {
+  get(key) {
+    try {
+      return localStorage.getItem(key);
+    } catch {
+      return null;
+    }
+  }
+  set(key, value) {
+    try {
+      localStorage.setItem(key, value);
+    } catch {
+    }
+  }
+  remove(key) {
+    try {
+      localStorage.removeItem(key);
+    } catch {
+    }
+  }
+};
+var MemoryStorage = class {
+  data = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.data.get(key) ?? null;
+  }
+  set(key, value) {
+    this.data.set(key, value);
+  }
+  remove(key) {
+    this.data.delete(key);
+  }
+};
+function createStorage(persistence) {
+  if (persistence === "localStorage" && typeof localStorage !== "undefined") {
+    try {
+      const testKey = "tell_test";
+      localStorage.setItem(testKey, "1");
+      localStorage.removeItem(testKey);
+      return new LocalStorageStorage();
+    } catch {
+    }
+  }
+  return new MemoryStorage();
+}
+
+// src/id.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
+      ""
+    );
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/bot.ts
+function isBot() {
+  if (typeof navigator === "undefined") return false;
+  if (navigator.webdriver === true) return true;
+  const ua = navigator.userAgent || "";
+  return /headless/i.test(ua);
+}
+
+// src/context.ts
+function captureContext() {
+  const ctx = {};
+  if (typeof navigator !== "undefined") {
+    const ua = navigator.userAgent || "";
+    const parsed = parseUA(ua);
+    ctx.browser = parsed.browser;
+    ctx.browser_version = parsed.browserVersion;
+    ctx.os_name = parsed.os;
+    ctx.os_version = parsed.osVersion;
+    ctx.device_type = inferDeviceType(parsed.os);
+    ctx.locale = navigator.language;
+    if ("hardwareConcurrency" in navigator) {
+      ctx.cpu_cores = navigator.hardwareConcurrency;
+    }
+    if ("deviceMemory" in navigator) {
+      ctx.device_memory = navigator.deviceMemory;
+    }
+    if ("maxTouchPoints" in navigator) {
+      ctx.touch = navigator.maxTouchPoints > 0;
+    }
+    const conn = navigator.connection;
+    if (conn?.effectiveType) {
+      ctx.connection_type = conn.effectiveType;
+    }
+  }
+  if (typeof screen !== "undefined") {
+    ctx.screen_width = screen.width;
+    ctx.screen_height = screen.height;
+  }
+  if (typeof window !== "undefined") {
+    ctx.viewport_width = window.innerWidth;
+    ctx.viewport_height = window.innerHeight;
+    if (window.devicePixelRatio) {
+      ctx.device_pixel_ratio = window.devicePixelRatio;
+    }
+  }
+  if (typeof document !== "undefined") {
+    ctx.referrer = document.referrer || void 0;
+    if (ctx.referrer) {
+      try {
+        ctx.referrer_domain = new URL(ctx.referrer).hostname;
+      } catch {
+      }
+    }
+    ctx.title = document.title || void 0;
+  }
+  if (typeof location !== "undefined") {
+    ctx.url = location.href;
+  }
+  try {
+    ctx.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+  }
+  return ctx;
+}
+function inferDeviceType(os) {
+  if (os === "iOS" || os === "Android") return "mobile";
+  return "desktop";
+}
+function parseUA(ua) {
+  const result = {};
+  if (/Edg\/(\d+[\d.]*)/.test(ua)) {
+    result.browser = "Edge";
+    result.browserVersion = RegExp.$1;
+  } else if (/OPR\/(\d+[\d.]*)/.test(ua)) {
+    result.browser = "Opera";
+    result.browserVersion = RegExp.$1;
+  } else if (/Chrome\/(\d+[\d.]*)/.test(ua)) {
+    result.browser = "Chrome";
+    result.browserVersion = RegExp.$1;
+  } else if (/Safari\/[\d.]+/.test(ua) && /Version\/(\d+[\d.]*)/.test(ua)) {
+    result.browser = "Safari";
+    result.browserVersion = RegExp.$1;
+  } else if (/Firefox\/(\d+[\d.]*)/.test(ua)) {
+    result.browser = "Firefox";
+    result.browserVersion = RegExp.$1;
+  }
+  if (/Windows NT ([\d.]+)/.test(ua)) {
+    result.os = "Windows";
+    result.osVersion = RegExp.$1;
+  } else if (/Mac OS X ([\d_.]+)/.test(ua)) {
+    result.os = "macOS";
+    result.osVersion = RegExp.$1.replace(/_/g, ".");
+  } else if (/iPhone OS ([\d_]+)/.test(ua)) {
+    result.os = "iOS";
+    result.osVersion = RegExp.$1.replace(/_/g, ".");
+  } else if (/Android ([\d.]+)/.test(ua)) {
+    result.os = "Android";
+    result.osVersion = RegExp.$1;
+  } else if (/Linux/.test(ua)) {
+    result.os = "Linux";
+  }
+  return result;
+}
+
+// src/utm.ts
+var UTM_KEYS = [
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content"
+];
+function captureUtm() {
+  if (typeof window === "undefined" || !window.location?.search) return {};
+  const params = new URLSearchParams(window.location.search);
+  const utm = {};
+  for (const key of UTM_KEYS) {
+    const value = params.get(key);
+    if (value) {
+      utm[key] = value;
+    }
+  }
+  return utm;
+}
+
+// src/session.ts
+var SessionManager = class {
+  _sessionId;
+  lastHiddenAt = 0;
+  lastActivityAt;
+  timeout;
+  onNewSession;
+  visibilityHandler;
+  checkTimer;
+  lastContextAt = {};
+  constructor(config) {
+    this.timeout = config.timeout;
+    this.onNewSession = config.onNewSession;
+    this._sessionId = generateId();
+    this.lastActivityAt = Date.now();
+    this.emitContext("session_start");
+    this.visibilityHandler = () => this.handleVisibility();
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", this.visibilityHandler);
+    }
+    this.checkTimer = setInterval(() => this.checkTimeout(), 6e4);
+    if (typeof this.checkTimer.unref === "function") {
+      this.checkTimer.unref();
+    }
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  set sessionId(id) {
+    this._sessionId = id;
+  }
+  touch() {
+    this.lastActivityAt = Date.now();
+  }
+  destroy() {
+    if (typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+    }
+    clearInterval(this.checkTimer);
+  }
+  handleVisibility() {
+    if (document.visibilityState === "hidden") {
+      this.lastHiddenAt = Date.now();
+    } else if (document.visibilityState === "visible") {
+      if (this.lastHiddenAt > 0 && Date.now() - this.lastHiddenAt > this.timeout) {
+        this.rotateSession("session_timeout");
+      } else if (this.lastHiddenAt > 0) {
+        this.emitContext("app_foreground");
+      }
+      this.lastHiddenAt = 0;
+    }
+  }
+  checkTimeout() {
+    if (Date.now() - this.lastActivityAt > this.timeout) {
+      this.rotateSession("session_timeout");
+    }
+  }
+  rotateSession(reason) {
+    this._sessionId = generateId();
+    this.lastActivityAt = Date.now();
+    this.emitContext(reason);
+  }
+  emitContext(reason) {
+    const now = Date.now();
+    const last = this.lastContextAt[reason] ?? 0;
+    if (now - last < 1e3) return;
+    this.lastContextAt[reason] = now;
+    this.onNewSession(reason, this._sessionId);
+  }
+};
+
+// src/transport.ts
+var BrowserTransport = class {
+  endpoint;
+  apiKey;
+  maxRetries;
+  networkTimeout;
+  onError;
+  onPayloadTooLarge;
+  constructor(config) {
+    this.endpoint = config.endpoint;
+    this.apiKey = config.apiKey;
+    this.maxRetries = config.maxRetries;
+    this.networkTimeout = config.networkTimeout;
+    this.onError = config.onError;
+    this.onPayloadTooLarge = config.onPayloadTooLarge;
+  }
+  async sendEvents(events) {
+    if (events.length === 0) return;
+    const body = events.map((e) => JSON.stringify(e)).join("\n");
+    await this.send("/v1/events", body);
+  }
+  async sendLogs(logs) {
+    if (logs.length === 0) return;
+    const body = logs.map((l) => JSON.stringify(l)).join("\n");
+    await this.send("/v1/logs", body);
+  }
+  /** Best-effort flush via sendBeacon for page unload. */
+  beacon(events, logs) {
+    if (typeof navigator === "undefined" || !navigator.sendBeacon) return;
+    if (events.length > 0) {
+      const body = events.map((e) => JSON.stringify(e)).join("\n");
+      const blob = new Blob([body], { type: "application/x-ndjson" });
+      const url = `${this.endpoint}/v1/events?token=${encodeURIComponent(this.apiKey)}`;
+      navigator.sendBeacon(url, blob);
+    }
+    if (logs.length > 0) {
+      const body = logs.map((l) => JSON.stringify(l)).join("\n");
+      const blob = new Blob([body], { type: "application/x-ndjson" });
+      const url = `${this.endpoint}/v1/logs?token=${encodeURIComponent(this.apiKey)}`;
+      navigator.sendBeacon(url, blob);
+    }
+  }
+  async send(path, body) {
+    const url = `${this.endpoint}${path}`;
+    const headers = {
+      "Content-Type": "application/x-ndjson",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        await this.backoff(attempt);
+      }
+      if (typeof navigator !== "undefined" && !navigator.onLine) {
+        lastError = new NetworkError("Browser is offline");
+        continue;
+      }
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(
+          () => controller.abort(),
+          this.networkTimeout
+        );
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body,
+          signal: controller.signal,
+          keepalive: true
+        });
+        clearTimeout(timer);
+        if (response.status === 202) {
+          return;
+        }
+        if (response.status === 207) {
+          if (this.onError) {
+            this.onError(
+              new NetworkError(
+                `Partial success: some items rejected`,
+                207
+              )
+            );
+          }
+          return;
+        }
+        if (response.status === 413) {
+          if (this.onPayloadTooLarge) {
+            this.onPayloadTooLarge();
+          }
+          throw new NetworkError("Payload too large", 413);
+        }
+        if (response.status === 401) {
+          throw new NetworkError("Invalid API key", 401);
+        }
+        if (response.status >= 400 && response.status < 500) {
+          throw new NetworkError(
+            `HTTP ${response.status}: ${response.statusText}`,
+            response.status
+          );
+        }
+        lastError = new NetworkError(
+          `HTTP ${response.status}: ${response.statusText}`,
+          response.status
+        );
+      } catch (err) {
+        if (err instanceof NetworkError && err.statusCode === 413) {
+          throw err;
+        }
+        if (err instanceof NetworkError && err.statusCode && err.statusCode < 500) {
+          if (this.onError) this.onError(err);
+          return;
+        }
+        lastError = err instanceof Error ? err : new NetworkError(String(err));
+      }
+    }
+    if (lastError && this.onError) {
+      this.onError(lastError);
+    }
+  }
+  backoff(attempt) {
+    const base = 1e3 * Math.pow(1.5, attempt - 1);
+    const jitter = base * 0.2 * Math.random();
+    const delay = Math.min(base + jitter, 3e4);
+    return new Promise((resolve) => setTimeout(resolve, delay));
+  }
+};
+
+// src/queue.ts
+var PreInitQueue = class {
+  items = [];
+  maxSize;
+  constructor(maxSize = 1e3) {
+    this.maxSize = maxSize;
+  }
+  push(call) {
+    if (this.items.length >= this.maxSize) {
+      this.items.shift();
+    }
+    this.items.push(call);
+  }
+  replay(target) {
+    const calls = this.items;
+    this.items = [];
+    for (const call of calls) {
+      try {
+        target[call.method](...call.args);
+      } catch {
+      }
+    }
+  }
+  get length() {
+    return this.items.length;
+  }
+  clear() {
+    this.items = [];
+  }
+};
+
+// src/index.ts
+var configured = false;
+var closed = false;
+var _disabled = false;
+var _optedOut = false;
+var storage;
+var transport;
+var eventBatcher;
+var logBatcher;
+var sessionManager;
+var resolvedConfig;
+var _apiKey;
+var deviceId;
+var userId;
+var superProperties = {};
+var beforeSend;
+var beforeSendLog;
+var sdkLogLevel;
+var queue = new PreInitQueue(1e3);
+var unloadHandler = null;
+var visibilityUnloadHandler = null;
+var errorHandler = null;
+var rejectionHandler = null;
+var LOG_LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+function reportError(err) {
+  if (resolvedConfig?.onError && err instanceof Error) {
+    resolvedConfig.onError(err);
+  }
+}
+function sdkDebug(msg) {
+  if (sdkLogLevel >= LOG_LEVELS.debug) {
+    console.debug(`[Tell] ${msg}`);
+  }
+}
+function handleUnload() {
+  const events = eventBatcher.drain();
+  const logs = logBatcher.drain();
+  transport.beacon(events, logs);
+}
+function handleVisibilityUnload() {
+  if (document.visibilityState === "hidden") {
+    handleUnload();
+  }
+}
+function onNewSession(reason, sessionId) {
+  if (_disabled || _optedOut || closed) return;
+  const ctx = captureContext();
+  const event = {
+    type: "context",
+    device_id: deviceId,
+    session_id: sessionId,
+    user_id: userId,
+    timestamp: Date.now(),
+    context: { reason, ...ctx }
+  };
+  eventBatcher.add(event);
+}
+function persistSuperProps() {
+  storage.set(STORAGE_KEYS.SUPER_PROPS, JSON.stringify(superProperties));
+}
+function loadSuperProps() {
+  const raw = storage.get(STORAGE_KEYS.SUPER_PROPS);
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    storage.remove(STORAGE_KEYS.SUPER_PROPS);
+    return {};
+  }
+}
+var tell = {
+  // -----------------------------------------------------------------------
+  // Lifecycle
+  // -----------------------------------------------------------------------
+  configure(apiKey, options) {
+    if (configured) {
+      reportError(new ConfigurationError("Tell is already configured"));
+      return;
+    }
+    validateApiKey(apiKey);
+    _apiKey = apiKey;
+    resolvedConfig = resolveConfig(options);
+    sdkLogLevel = LOG_LEVELS[resolvedConfig.logLevel] ?? 0;
+    beforeSend = resolvedConfig.beforeSend;
+    beforeSendLog = resolvedConfig.beforeSendLog;
+    _disabled = resolvedConfig.disabled;
+    storage = createStorage(resolvedConfig.persistence);
+    deviceId = storage.get(STORAGE_KEYS.DEVICE_ID) ?? generateId();
+    storage.set(STORAGE_KEYS.DEVICE_ID, deviceId);
+    userId = storage.get(STORAGE_KEYS.USER_ID) ?? void 0;
+    _optedOut = storage.get(STORAGE_KEYS.OPT_OUT) === "1";
+    superProperties = loadSuperProps();
+    const utm = captureUtm();
+    if (Object.keys(utm).length > 0) {
+      Object.assign(superProperties, utm);
+      persistSuperProps();
+    }
+    if (resolvedConfig.botDetection && isBot()) {
+      _disabled = true;
+      sdkDebug("bot detected, disabling");
+    }
+    if (resolvedConfig.respectDoNotTrack && typeof navigator !== "undefined" && navigator.doNotTrack === "1") {
+      _disabled = true;
+      sdkDebug("Do Not Track enabled, disabling");
+    }
+    transport = new BrowserTransport({
+      endpoint: resolvedConfig.endpoint,
+      apiKey: _apiKey,
+      maxRetries: resolvedConfig.maxRetries,
+      networkTimeout: resolvedConfig.networkTimeout,
+      onError: resolvedConfig.onError,
+      onPayloadTooLarge: () => {
+        eventBatcher.halveBatchSize();
+        logBatcher.halveBatchSize();
+        sdkDebug("413 received, halved batch size");
+      }
+    });
+    eventBatcher = new Batcher({
+      size: resolvedConfig.batchSize,
+      interval: resolvedConfig.flushInterval,
+      maxQueueSize: resolvedConfig.maxQueueSize,
+      send: (items) => transport.sendEvents(items),
+      onOverflow: () => sdkDebug("event queue overflow, dropping oldest")
+    });
+    logBatcher = new Batcher({
+      size: resolvedConfig.batchSize,
+      interval: resolvedConfig.flushInterval,
+      maxQueueSize: resolvedConfig.maxQueueSize,
+      send: (items) => transport.sendLogs(items),
+      onOverflow: () => sdkDebug("log queue overflow, dropping oldest")
+    });
+    sessionManager = new SessionManager({
+      timeout: resolvedConfig.sessionTimeout,
+      onNewSession
+    });
+    if (typeof window !== "undefined") {
+      unloadHandler = handleUnload;
+      window.addEventListener("beforeunload", unloadHandler);
+    }
+    if (typeof document !== "undefined") {
+      visibilityUnloadHandler = handleVisibilityUnload;
+      document.addEventListener("visibilitychange", visibilityUnloadHandler);
+    }
+    if (resolvedConfig.captureErrors && typeof window !== "undefined") {
+      errorHandler = (event) => {
+        if (_disabled || _optedOut || closed) return;
+        const msg = event.message || "Unknown error";
+        const data = {};
+        if (event.filename) data.filename = event.filename;
+        if (event.lineno) data.lineno = event.lineno;
+        if (event.colno) data.colno = event.colno;
+        if (event.error?.stack) data.stack = event.error.stack;
+        tell.logError(msg, "browser", data);
+      };
+      rejectionHandler = (event) => {
+        if (_disabled || _optedOut || closed) return;
+        const reason = event.reason;
+        const msg = reason instanceof Error ? reason.message : String(reason ?? "Unhandled promise rejection");
+        const data = {};
+        if (reason instanceof Error && reason.stack) data.stack = reason.stack;
+        tell.logError(msg, "browser", data);
+      };
+      window.addEventListener("error", errorHandler);
+      window.addEventListener("unhandledrejection", rejectionHandler);
+    }
+    configured = true;
+    closed = false;
+    sdkDebug(
+      `configured (endpoint=${resolvedConfig.endpoint}, batch=${resolvedConfig.batchSize})`
+    );
+    queue.replay(tell);
+  },
+  // -----------------------------------------------------------------------
+  // Events
+  // -----------------------------------------------------------------------
+  track(eventName, properties) {
+    if (!configured) {
+      queue.push({ method: "track", args: [eventName, properties] });
+      return;
+    }
+    if (_disabled || _optedOut) return;
+    if (closed) {
+      reportError(new ClosedError());
+      return;
+    }
+    try {
+      validateEventName(eventName);
+    } catch (err) {
+      reportError(err);
+      return;
+    }
+    let event = {
+      type: "track",
+      event: eventName,
+      device_id: deviceId,
+      session_id: sessionManager.sessionId,
+      user_id: userId,
+      timestamp: Date.now(),
+      properties: { ...superProperties, ...properties }
+    };
+    if (beforeSend) {
+      event = runBeforeSend(event, beforeSend);
+      if (event === null) return;
+    }
+    sessionManager.touch();
+    eventBatcher.add(event);
+  },
+  identify(newUserId, traits) {
+    if (!configured) {
+      queue.push({ method: "identify", args: [newUserId, traits] });
+      return;
+    }
+    if (_disabled || _optedOut) return;
+    if (closed) {
+      reportError(new ClosedError());
+      return;
+    }
+    try {
+      validateUserId(newUserId);
+    } catch (err) {
+      reportError(err);
+      return;
+    }
+    userId = newUserId;
+    storage.set(STORAGE_KEYS.USER_ID, userId);
+    let event = {
+      type: "identify",
+      device_id: deviceId,
+      session_id: sessionManager.sessionId,
+      user_id: userId,
+      timestamp: Date.now(),
+      traits
+    };
+    if (beforeSend) {
+      event = runBeforeSend(event, beforeSend);
+      if (event === null) return;
+    }
+    sessionManager.touch();
+    eventBatcher.add(event);
+  },
+  group(groupId, properties) {
+    if (!configured) {
+      queue.push({ method: "group", args: [groupId, properties] });
+      return;
+    }
+    if (_disabled || _optedOut) return;
+    if (closed) {
+      reportError(new ClosedError());
+      return;
+    }
+    try {
+      if (!groupId) throw new ValidationError("groupId", "is required");
+    } catch (err) {
+      reportError(err);
+      return;
+    }
+    let event = {
+      type: "group",
+      device_id: deviceId,
+      session_id: sessionManager.sessionId,
+      user_id: userId,
+      group_id: groupId,
+      timestamp: Date.now(),
+      properties: { ...superProperties, ...properties }
+    };
+    if (beforeSend) {
+      event = runBeforeSend(event, beforeSend);
+      if (event === null) return;
+    }
+    sessionManager.touch();
+    eventBatcher.add(event);
+  },
+  revenue(amount, currency, orderId, properties) {
+    if (!configured) {
+      queue.push({ method: "revenue", args: [amount, currency, orderId, properties] });
+      return;
+    }
+    if (_disabled || _optedOut) return;
+    if (closed) {
+      reportError(new ClosedError());
+      return;
+    }
+    try {
+      if (amount <= 0) throw new ValidationError("amount", "must be positive");
+      if (!currency) throw new ValidationError("currency", "is required");
+      if (!orderId) throw new ValidationError("orderId", "is required");
+    } catch (err) {
+      reportError(err);
+      return;
+    }
+    let event = {
+      type: "track",
+      event: "Order Completed",
+      device_id: deviceId,
+      session_id: sessionManager.sessionId,
+      user_id: userId,
+      timestamp: Date.now(),
+      properties: {
+        ...superProperties,
+        ...properties,
+        order_id: orderId,
+        amount,
+        currency
+      }
+    };
+    if (beforeSend) {
+      event = runBeforeSend(event, beforeSend);
+      if (event === null) return;
+    }
+    sessionManager.touch();
+    eventBatcher.add(event);
+  },
+  alias(previousId, newUserId) {
+    if (!configured) {
+      queue.push({ method: "alias", args: [previousId, newUserId] });
+      return;
+    }
+    if (_disabled || _optedOut) return;
+    if (closed) {
+      reportError(new ClosedError());
+      return;
+    }
+    try {
+      if (!previousId)
+        throw new ValidationError("previousId", "is required");
+      validateUserId(newUserId);
+    } catch (err) {
+      reportError(err);
+      return;
+    }
+    let event = {
+      type: "alias",
+      device_id: deviceId,
+      session_id: sessionManager.sessionId,
+      user_id: newUserId,
+      timestamp: Date.now(),
+      properties: { previous_id: previousId }
+    };
+    if (beforeSend) {
+      event = runBeforeSend(event, beforeSend);
+      if (event === null) return;
+    }
+    sessionManager.touch();
+    eventBatcher.add(event);
+  },
+  // -----------------------------------------------------------------------
+  // Logging
+  // -----------------------------------------------------------------------
+  log(level, message, service, data) {
+    if (!configured) {
+      queue.push({ method: "log", args: [level, message, service, data] });
+      return;
+    }
+    if (_disabled || _optedOut) return;
+    if (closed) {
+      reportError(new ClosedError());
+      return;
+    }
+    try {
+      validateLogMessage(message);
+    } catch (err) {
+      reportError(err);
+      return;
+    }
+    let logEntry = {
+      level,
+      message,
+      source: resolvedConfig.source,
+      service: service ?? "app",
+      session_id: sessionManager.sessionId,
+      timestamp: Date.now(),
+      data
+    };
+    if (beforeSendLog) {
+      logEntry = runBeforeSend(logEntry, beforeSendLog);
+      if (logEntry === null) return;
+    }
+    logBatcher.add(logEntry);
+  },
+  logEmergency(message, service, data) {
+    tell.log("emergency", message, service, data);
+  },
+  logAlert(message, service, data) {
+    tell.log("alert", message, service, data);
+  },
+  logCritical(message, service, data) {
+    tell.log("critical", message, service, data);
+  },
+  logError(message, service, data) {
+    tell.log("error", message, service, data);
+  },
+  logWarning(message, service, data) {
+    tell.log("warning", message, service, data);
+  },
+  logNotice(message, service, data) {
+    tell.log("notice", message, service, data);
+  },
+  logInfo(message, service, data) {
+    tell.log("info", message, service, data);
+  },
+  logDebug(message, service, data) {
+    tell.log("debug", message, service, data);
+  },
+  logTrace(message, service, data) {
+    tell.log("trace", message, service, data);
+  },
+  // -----------------------------------------------------------------------
+  // Super Properties
+  // -----------------------------------------------------------------------
+  register(properties) {
+    if (!configured) {
+      queue.push({ method: "register", args: [properties] });
+      return;
+    }
+    Object.assign(superProperties, properties);
+    persistSuperProps();
+  },
+  unregister(key) {
+    if (!configured) {
+      queue.push({ method: "unregister", args: [key] });
+      return;
+    }
+    delete superProperties[key];
+    persistSuperProps();
+  },
+  // -----------------------------------------------------------------------
+  // Privacy
+  // -----------------------------------------------------------------------
+  optOut() {
+    if (!configured) {
+      queue.push({ method: "optOut", args: [] });
+      return;
+    }
+    _optedOut = true;
+    storage.set(STORAGE_KEYS.OPT_OUT, "1");
+  },
+  optIn() {
+    if (!configured) {
+      queue.push({ method: "optIn", args: [] });
+      return;
+    }
+    _optedOut = false;
+    storage.remove(STORAGE_KEYS.OPT_OUT);
+  },
+  isOptedOut() {
+    return _optedOut;
+  },
+  // -----------------------------------------------------------------------
+  // Control
+  // -----------------------------------------------------------------------
+  enable() {
+    _disabled = false;
+  },
+  disable() {
+    _disabled = true;
+  },
+  // -----------------------------------------------------------------------
+  // Lifecycle
+  // -----------------------------------------------------------------------
+  async flush() {
+    if (!configured) return;
+    await Promise.all([eventBatcher.flush(), logBatcher.flush()]);
+  },
+  async close() {
+    if (!configured || closed) return;
+    closed = true;
+    if (sessionManager) sessionManager.destroy();
+    if (typeof window !== "undefined" && unloadHandler) {
+      window.removeEventListener("beforeunload", unloadHandler);
+      unloadHandler = null;
+    }
+    if (typeof document !== "undefined" && visibilityUnloadHandler) {
+      document.removeEventListener("visibilitychange", visibilityUnloadHandler);
+      visibilityUnloadHandler = null;
+    }
+    if (typeof window !== "undefined") {
+      if (errorHandler) {
+        window.removeEventListener("error", errorHandler);
+        errorHandler = null;
+      }
+      if (rejectionHandler) {
+        window.removeEventListener("unhandledrejection", rejectionHandler);
+        rejectionHandler = null;
+      }
+    }
+    const work = Promise.all([eventBatcher.close(), logBatcher.close()]);
+    const timeout = new Promise(
+      (_, reject) => setTimeout(
+        () => reject(new Error("close timed out")),
+        resolvedConfig.closeTimeout
+      )
+    );
+    try {
+      await Promise.race([work, timeout]);
+    } catch (err) {
+      reportError(err);
+    }
+  },
+  reset() {
+    if (!configured) return;
+    userId = void 0;
+    deviceId = generateId();
+    superProperties = {};
+    storage.remove(STORAGE_KEYS.USER_ID);
+    storage.set(STORAGE_KEYS.DEVICE_ID, deviceId);
+    storage.remove(STORAGE_KEYS.SUPER_PROPS);
+    if (sessionManager) {
+      sessionManager.sessionId = generateId();
+    }
+  },
+  // -----------------------------------------------------------------------
+  // Testing helper
+  // -----------------------------------------------------------------------
+  _resetForTesting() {
+    if (configured && !closed) {
+      if (sessionManager) sessionManager.destroy();
+      if (eventBatcher) {
+        eventBatcher.drain();
+        eventBatcher.close().catch(() => {
+        });
+      }
+      if (logBatcher) {
+        logBatcher.drain();
+        logBatcher.close().catch(() => {
+        });
+      }
+      if (typeof window !== "undefined" && unloadHandler) {
+        window.removeEventListener("beforeunload", unloadHandler);
+      }
+      if (typeof document !== "undefined" && visibilityUnloadHandler) {
+        document.removeEventListener(
+          "visibilitychange",
+          visibilityUnloadHandler
+        );
+      }
+      if (typeof window !== "undefined") {
+        if (errorHandler) window.removeEventListener("error", errorHandler);
+        if (rejectionHandler)
+          window.removeEventListener("unhandledrejection", rejectionHandler);
+      }
+    }
+    configured = false;
+    closed = false;
+    _disabled = false;
+    _optedOut = false;
+    userId = void 0;
+    deviceId = "";
+    superProperties = {};
+    beforeSend = void 0;
+    beforeSendLog = void 0;
+    sdkLogLevel = 0;
+    unloadHandler = null;
+    visibilityUnloadHandler = null;
+    errorHandler = null;
+    rejectionHandler = null;
+    queue.clear();
+  }
+};
+var index_default = tell;
+//# sourceMappingURL=index.cjs.map