@shellapps/experience 1.0.1 → 1.2.0

package/dist/index.mjs

@@ -1,453 +1,2579 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+var Severity = /* @__PURE__ */ ((Severity2) => {
+  Severity2[Severity2["INFO"] = 0] = "INFO";
+  Severity2[Severity2["WARNING"] = 1] = "WARNING";
+  Severity2[Severity2["ERROR"] = 2] = "ERROR";
+  Severity2[Severity2["FATAL"] = 3] = "FATAL";
+  return Severity2;
+})(Severity || {});
+
+// src/session.ts
+var SESSION_STORAGE_KEY = "shellapps_experience_session";
+var SessionManager = class {
+  constructor() {
+    this.session = null;
+    this.initializeSession();
+  }
+  generateUUID() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    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);
+    });
+  }
+  initializeSession() {
+    if (typeof sessionStorage !== "undefined") {
+      try {
+        const storedSession = sessionStorage.getItem(SESSION_STORAGE_KEY);
+        if (storedSession) {
+          const parsed = JSON.parse(storedSession);
+          this.session = {
+            id: parsed.id,
+            startTime: parsed.startTime,
+            getDuration: () => Date.now() - parsed.startTime
+          };
+          return;
+        }
+      } catch (error) {
+      }
+    }
+    this.createNewSession();
+  }
+  createNewSession() {
+    const startTime = Date.now();
+    const sessionId = this.generateUUID();
+    this.session = {
+      id: sessionId,
+      startTime,
+      getDuration: () => Date.now() - startTime
+    };
+    if (typeof sessionStorage !== "undefined") {
+      try {
+        sessionStorage.setItem(SESSION_STORAGE_KEY, JSON.stringify({
+          id: sessionId,
+          startTime
+        }));
+      } catch (error) {
+      }
+    }
+  }
+  getCurrentSession() {
+    if (!this.session) {
+      this.createNewSession();
+    }
+    return this.session;
+  }
+  getSessionId() {
+    return this.getCurrentSession().id;
+  }
+  getSessionDuration() {
+    return this.getCurrentSession().getDuration();
+  }
+  renewSession() {
+    this.createNewSession();
+  }
+};
+
+// src/proto/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  BreadcrumbCategoryEnum: () => BreadcrumbCategoryEnum,
+  BreadcrumbLevelEnum: () => BreadcrumbLevelEnum,
+  BreadcrumbSchema: () => BreadcrumbSchema,
+  BrowserContextSchema: () => BrowserContextSchema,
+  ElementContextSchema: () => ElementContextSchema,
+  ErrorBatchSchema: () => ErrorBatchSchema,
+  ErrorEventSchema: () => ErrorEventSchema,
+  EventBatchSchema: () => EventBatchSchema,
+  HeatmapEventSchema: () => HeatmapEventSchema,
+  HeatmapTypeEnum: () => HeatmapTypeEnum,
+  IngestResponseSchema: () => IngestResponseSchema,
+  PageContextSchema: () => PageContextSchema,
+  PositionSchema: () => PositionSchema,
+  SeverityEnum: () => SeverityEnum,
+  TrackEventSchema: () => TrackEventSchema,
+  ViewportSchema: () => ViewportSchema,
+  WireType: () => WireType
+});
+var TrackEventSchema = {
+  eventType: 1,
+  sessionId: 2,
+  timestamp: 3,
+  metadata: 4,
+  pageContext: 5,
+  elementContext: 6
+};
+var PageContextSchema = {
+  url: 1,
+  title: 2,
+  referrer: 3,
+  viewport: 4,
+  loadTime: 5
+};
+var ViewportSchema = {
+  width: 1,
+  height: 2
+};
+var ElementContextSchema = {
+  selector: 1,
+  dataT: 2,
+  tag: 3,
+  position: 4
+};
+var PositionSchema = {
+  x: 1,
+  y: 2
+};
+var HeatmapEventSchema = {
+  sessionId: 1,
+  timestamp: 2,
+  type: 3,
+  x: 4,
+  y: 5,
+  viewportWidth: 6,
+  viewportHeight: 7,
+  url: 8
+};
+var EventBatchSchema = {
+  events: 1,
+  heatmapEvents: 2
+};
+var IngestResponseSchema = {
+  success: 1,
+  message: 2
+};
+var ErrorEventSchema = {
+  sessionId: 1,
+  timestamp: 2,
+  message: 3,
+  filename: 4,
+  lineno: 5,
+  colno: 6,
+  stack: 7,
+  severity: 8,
+  breadcrumbs: 9,
+  browserContext: 10,
+  tags: 11,
+  extra: 12
+};
+var BreadcrumbSchema = {
+  timestamp: 1,
+  category: 2,
+  message: 3,
+  data: 4,
+  level: 5
+};
+var BrowserContextSchema = {
+  userAgent: 1,
+  url: 2,
+  timestamp: 3,
+  viewport: 4
+};
+var ErrorBatchSchema = {
+  errors: 1
+};
+var WireType = {
+  VARINT: 0,
+  FIXED64: 1,
+  LENGTH_DELIMITED: 2,
+  START_GROUP: 3,
+  END_GROUP: 4,
+  FIXED32: 5
+};
+var SeverityEnum = {
+  INFO: 0,
+  WARNING: 1,
+  ERROR: 2,
+  FATAL: 3
+};
+var HeatmapTypeEnum = {
+  click: 0,
+  move: 1,
+  hover: 2
+};
+var BreadcrumbCategoryEnum = {
+  navigation: 0,
+  click: 1,
+  console: 2,
+  fetch: 3,
+  xhr: 4,
+  ui: 5
+};
+var BreadcrumbLevelEnum = {
+  info: 0,
+  warning: 1,
+  error: 2
+};
+
+// src/proto/encode.ts
+var ProtobufEncoder = class _ProtobufEncoder {
+  constructor() {
+    this.buffer = [];
+  }
+  // Helper methods for encoding
+  encodeVarint(value) {
+    while (value >= 128) {
+      this.buffer.push(value & 127 | 128);
+      value >>>= 7;
+    }
+    this.buffer.push(value & 127);
+  }
+  encodeTag(fieldNumber, wireType) {
+    this.encodeVarint(fieldNumber << 3 | wireType);
+  }
+  encodeString(value) {
+    const utf8Bytes = new TextEncoder().encode(value);
+    this.encodeVarint(utf8Bytes.length);
+    this.buffer.push(...utf8Bytes);
+  }
+  encodeUint64(value) {
+    this.encodeVarint(value);
+  }
+  encodeUint32(value) {
+    this.encodeVarint(value);
+  }
+  encodeBool(value) {
+    this.buffer.push(value ? 1 : 0);
+  }
+  encodeMessage(encoder) {
+    const startLength = this.buffer.length;
+    encoder();
+    const messageLength = this.buffer.length - startLength;
+    const lengthBytes = [];
+    let length = messageLength;
+    while (length >= 128) {
+      lengthBytes.push(length & 127 | 128);
+      length >>>= 7;
+    }
+    lengthBytes.push(length & 127);
+    this.buffer.splice(startLength, 0, ...lengthBytes);
+    return new Uint8Array(this.buffer.slice(startLength + lengthBytes.length));
+  }
+  encodeMapEntry(key, value) {
+    const entryEncoder = new _ProtobufEncoder();
+    entryEncoder.encodeTag(1, WireType.LENGTH_DELIMITED);
+    entryEncoder.encodeString(key);
+    entryEncoder.encodeTag(2, WireType.LENGTH_DELIMITED);
+    entryEncoder.encodeString(value);
+    this.encodeVarint(entryEncoder.buffer.length);
+    this.buffer.push(...entryEncoder.buffer);
+  }
+  // Encode viewport
+  encodeViewport(viewport) {
+    if (viewport.width) {
+      this.encodeTag(ViewportSchema.width, WireType.VARINT);
+      this.encodeUint32(viewport.width);
+    }
+    if (viewport.height) {
+      this.encodeTag(ViewportSchema.height, WireType.VARINT);
+      this.encodeUint32(viewport.height);
+    }
+  }
+  // Encode position
+  encodePosition(position) {
+    this.encodeTag(PositionSchema.x, WireType.VARINT);
+    this.encodeUint32(position.x);
+    this.encodeTag(PositionSchema.y, WireType.VARINT);
+    this.encodeUint32(position.y);
+  }
+  // Encode PageContext
+  encodePageContext(pageContext) {
+    this.encodeTag(PageContextSchema.url, WireType.LENGTH_DELIMITED);
+    this.encodeString(pageContext.url);
+    this.encodeTag(PageContextSchema.title, WireType.LENGTH_DELIMITED);
+    this.encodeString(pageContext.title);
+    this.encodeTag(PageContextSchema.referrer, WireType.LENGTH_DELIMITED);
+    this.encodeString(pageContext.referrer);
+    if (pageContext.viewport) {
+      this.encodeTag(PageContextSchema.viewport, WireType.LENGTH_DELIMITED);
+      const viewportEncoder = new _ProtobufEncoder();
+      viewportEncoder.encodeViewport(pageContext.viewport);
+      this.encodeVarint(viewportEncoder.buffer.length);
+      this.buffer.push(...viewportEncoder.buffer);
+    }
+    if (pageContext.loadTime) {
+      this.encodeTag(PageContextSchema.loadTime, WireType.VARINT);
+      this.encodeUint64(pageContext.loadTime);
+    }
+  }
+  // Encode ElementContext
+  encodeElementContext(elementContext) {
+    this.encodeTag(ElementContextSchema.selector, WireType.LENGTH_DELIMITED);
+    this.encodeString(elementContext.selector);
+    if (elementContext.dataT) {
+      this.encodeTag(ElementContextSchema.dataT, WireType.LENGTH_DELIMITED);
+      this.encodeString(elementContext.dataT);
+    }
+    this.encodeTag(ElementContextSchema.tag, WireType.LENGTH_DELIMITED);
+    this.encodeString(elementContext.tag);
+    if (elementContext.position) {
+      this.encodeTag(ElementContextSchema.position, WireType.LENGTH_DELIMITED);
+      const positionEncoder = new _ProtobufEncoder();
+      positionEncoder.encodePosition(elementContext.position);
+      this.encodeVarint(positionEncoder.buffer.length);
+      this.buffer.push(...positionEncoder.buffer);
+    }
+  }
+  // Encode TrackEvent
+  encodeTrackEvent(event) {
+    this.encodeTag(TrackEventSchema.eventType, WireType.LENGTH_DELIMITED);
+    this.encodeString(event.eventType);
+    this.encodeTag(TrackEventSchema.sessionId, WireType.LENGTH_DELIMITED);
+    this.encodeString(event.sessionId);
+    this.encodeTag(TrackEventSchema.timestamp, WireType.VARINT);
+    this.encodeUint64(event.timestamp);
+    if (event.metadata) {
+      for (const [key, value] of Object.entries(event.metadata)) {
+        this.encodeTag(TrackEventSchema.metadata, WireType.LENGTH_DELIMITED);
+        this.encodeMapEntry(key, value);
+      }
+    }
+    if (event.pageContext) {
+      this.encodeTag(TrackEventSchema.pageContext, WireType.LENGTH_DELIMITED);
+      const pageContextEncoder = new _ProtobufEncoder();
+      pageContextEncoder.encodePageContext(event.pageContext);
+      this.encodeVarint(pageContextEncoder.buffer.length);
+      this.buffer.push(...pageContextEncoder.buffer);
+    }
+    if (event.elementContext) {
+      this.encodeTag(TrackEventSchema.elementContext, WireType.LENGTH_DELIMITED);
+      const elementContextEncoder = new _ProtobufEncoder();
+      elementContextEncoder.encodeElementContext(event.elementContext);
+      this.encodeVarint(elementContextEncoder.buffer.length);
+      this.buffer.push(...elementContextEncoder.buffer);
+    }
+  }
+  // Encode HeatmapEvent
+  encodeHeatmapEvent(event) {
+    this.encodeTag(HeatmapEventSchema.sessionId, WireType.LENGTH_DELIMITED);
+    this.encodeString(event.sessionId);
+    this.encodeTag(HeatmapEventSchema.timestamp, WireType.VARINT);
+    this.encodeUint64(event.timestamp);
+    this.encodeTag(HeatmapEventSchema.type, WireType.VARINT);
+    this.encodeUint32(HeatmapTypeEnum[event.type]);
+    this.encodeTag(HeatmapEventSchema.x, WireType.VARINT);
+    this.encodeUint32(event.x);
+    this.encodeTag(HeatmapEventSchema.y, WireType.VARINT);
+    this.encodeUint32(event.y);
+    this.encodeTag(HeatmapEventSchema.viewportWidth, WireType.VARINT);
+    this.encodeUint32(event.viewportWidth);
+    this.encodeTag(HeatmapEventSchema.viewportHeight, WireType.VARINT);
+    this.encodeUint32(event.viewportHeight);
+    this.encodeTag(HeatmapEventSchema.url, WireType.LENGTH_DELIMITED);
+    this.encodeString(event.url);
+  }
+  // Encode Breadcrumb
+  encodeBreadcrumb(breadcrumb) {
+    this.encodeTag(BreadcrumbSchema.timestamp, WireType.VARINT);
+    this.encodeUint64(breadcrumb.timestamp);
+    this.encodeTag(BreadcrumbSchema.category, WireType.VARINT);
+    this.encodeUint32(BreadcrumbCategoryEnum[breadcrumb.category]);
+    this.encodeTag(BreadcrumbSchema.message, WireType.LENGTH_DELIMITED);
+    this.encodeString(breadcrumb.message);
+    if (breadcrumb.data) {
+      for (const [key, value] of Object.entries(breadcrumb.data)) {
+        this.encodeTag(BreadcrumbSchema.data, WireType.LENGTH_DELIMITED);
+        this.encodeMapEntry(key, JSON.stringify(value));
+      }
+    }
+    if (breadcrumb.level) {
+      this.encodeTag(BreadcrumbSchema.level, WireType.VARINT);
+      this.encodeUint32(BreadcrumbLevelEnum[breadcrumb.level]);
+    }
+  }
+  // Encode BrowserContext
+  encodeBrowserContext(context) {
+    this.encodeTag(BrowserContextSchema.userAgent, WireType.LENGTH_DELIMITED);
+    this.encodeString(context.userAgent);
+    this.encodeTag(BrowserContextSchema.url, WireType.LENGTH_DELIMITED);
+    this.encodeString(context.url);
+    this.encodeTag(BrowserContextSchema.timestamp, WireType.VARINT);
+    this.encodeUint64(context.timestamp);
+    this.encodeTag(BrowserContextSchema.viewport, WireType.LENGTH_DELIMITED);
+    const viewportEncoder = new _ProtobufEncoder();
+    viewportEncoder.encodeViewport(context.viewport);
+    this.encodeVarint(viewportEncoder.buffer.length);
+    this.buffer.push(...viewportEncoder.buffer);
+  }
+  // Encode ErrorEvent
+  encodeErrorEvent(error) {
+    this.encodeTag(ErrorEventSchema.sessionId, WireType.LENGTH_DELIMITED);
+    this.encodeString(error.sessionId);
+    this.encodeTag(ErrorEventSchema.timestamp, WireType.VARINT);
+    this.encodeUint64(error.timestamp);
+    this.encodeTag(ErrorEventSchema.message, WireType.LENGTH_DELIMITED);
+    this.encodeString(error.message);
+    if (error.filename) {
+      this.encodeTag(ErrorEventSchema.filename, WireType.LENGTH_DELIMITED);
+      this.encodeString(error.filename);
+    }
+    if (error.lineno) {
+      this.encodeTag(ErrorEventSchema.lineno, WireType.VARINT);
+      this.encodeUint32(error.lineno);
+    }
+    if (error.colno) {
+      this.encodeTag(ErrorEventSchema.colno, WireType.VARINT);
+      this.encodeUint32(error.colno);
+    }
+    if (error.stack) {
+      this.encodeTag(ErrorEventSchema.stack, WireType.LENGTH_DELIMITED);
+      this.encodeString(error.stack);
+    }
+    this.encodeTag(ErrorEventSchema.severity, WireType.VARINT);
+    this.encodeUint32(error.severity);
+    for (const breadcrumb of error.breadcrumbs) {
+      this.encodeTag(ErrorEventSchema.breadcrumbs, WireType.LENGTH_DELIMITED);
+      const breadcrumbEncoder = new _ProtobufEncoder();
+      breadcrumbEncoder.encodeBreadcrumb(breadcrumb);
+      this.encodeVarint(breadcrumbEncoder.buffer.length);
+      this.buffer.push(...breadcrumbEncoder.buffer);
+    }
+    this.encodeTag(ErrorEventSchema.browserContext, WireType.LENGTH_DELIMITED);
+    const browserContextEncoder = new _ProtobufEncoder();
+    browserContextEncoder.encodeBrowserContext(error.browserContext);
+    this.encodeVarint(browserContextEncoder.buffer.length);
+    this.buffer.push(...browserContextEncoder.buffer);
+    if (error.tags) {
+      for (const [key, value] of Object.entries(error.tags)) {
+        this.encodeTag(ErrorEventSchema.tags, WireType.LENGTH_DELIMITED);
+        this.encodeMapEntry(key, value);
+      }
+    }
+    if (error.extra) {
+      for (const [key, value] of Object.entries(error.extra)) {
+        this.encodeTag(ErrorEventSchema.extra, WireType.LENGTH_DELIMITED);
+        this.encodeMapEntry(key, JSON.stringify(value));
+      }
+    }
+  }
+  // Public encoding methods
+  encodeEventBatch(batch) {
+    this.buffer = [];
+    for (const event of batch.events) {
+      this.encodeTag(EventBatchSchema.events, WireType.LENGTH_DELIMITED);
+      const eventEncoder = new _ProtobufEncoder();
+      eventEncoder.encodeTrackEvent(event);
+      this.encodeVarint(eventEncoder.buffer.length);
+      this.buffer.push(...eventEncoder.buffer);
+    }
+    for (const event of batch.heatmapEvents) {
+      this.encodeTag(EventBatchSchema.heatmapEvents, WireType.LENGTH_DELIMITED);
+      const eventEncoder = new _ProtobufEncoder();
+      eventEncoder.encodeHeatmapEvent(event);
+      this.encodeVarint(eventEncoder.buffer.length);
+      this.buffer.push(...eventEncoder.buffer);
+    }
+    return new Uint8Array(this.buffer);
+  }
+  encodeErrorBatch(batch) {
+    this.buffer = [];
+    for (const error of batch.errors) {
+      this.encodeTag(ErrorBatchSchema.errors, WireType.LENGTH_DELIMITED);
+      const errorEncoder = new _ProtobufEncoder();
+      errorEncoder.encodeErrorEvent(error);
+      this.encodeVarint(errorEncoder.buffer.length);
+      this.buffer.push(...errorEncoder.buffer);
+    }
+    return new Uint8Array(this.buffer);
+  }
+};
+
+// src/transport.ts
+var Transport = class {
+  constructor(config) {
+    this.config = config;
+    this.encoder = new ProtobufEncoder();
+  }
+  async sendProtobuf(endpoint, data) {
+    try {
+      const response = await fetch(`${this.config.endpoint}${endpoint}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-protobuf",
+          "X-API-Key": this.config.apiKey
+        },
+        body: data
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      try {
+        const result = await response.json();
+        return result;
+      } catch {
+        return { success: true };
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.error("[ExperienceSDK] Protobuf transport error:", error);
+      }
+      throw error;
+    }
+  }
+  async sendJSON(endpoint, data) {
+    try {
+      const response = await fetch(`${this.config.endpoint}${endpoint}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.config.apiKey
+        },
+        body: JSON.stringify(data)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      try {
+        const result = await response.json();
+        return result;
+      } catch {
+        return { success: true };
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.error("[ExperienceSDK] JSON transport error:", error);
+      }
+      throw error;
+    }
+  }
+  async sendEventBatch(batch) {
+    try {
+      if (!this.config.debug) {
+        const protobufData = this.encoder.encodeEventBatch(batch);
+        return await this.sendProtobuf("/api/v1/events/ingest", protobufData);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[ExperienceSDK] Protobuf failed, falling back to JSON:", error);
+      }
+    }
+    return this.sendJSON("/api/v1/events/ingest/json", batch);
+  }
+  async sendErrorBatch(batch) {
+    try {
+      if (!this.config.debug) {
+        const protobufData = this.encoder.encodeErrorBatch(batch);
+        return await this.sendProtobuf("/api/v1/errors/ingest", protobufData);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[ExperienceSDK] Protobuf failed, falling back to JSON:", error);
+      }
+    }
+    return this.sendJSON("/api/v1/errors/ingest/json", batch);
+  }
+  async sendEventBatchBeacon(batch) {
+    if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+      try {
+        const protobufData = this.encoder.encodeEventBatch(batch);
+        const blob = new Blob([protobufData], { type: "application/x-protobuf" });
+        const url = `${this.config.endpoint}/api/v1/events/ingest?api_key=${encodeURIComponent(this.config.apiKey)}`;
+        navigator.sendBeacon(url, blob);
+      } catch (error) {
+        if (this.config.debug) {
+          console.error("[ExperienceSDK] Beacon send error:", error);
+        }
+        try {
+          const jsonBlob = new Blob([JSON.stringify(batch)], { type: "application/json" });
+          const jsonUrl = `${this.config.endpoint}/api/v1/events/ingest/json?api_key=${encodeURIComponent(this.config.apiKey)}`;
+          navigator.sendBeacon(jsonUrl, jsonBlob);
+        } catch (fallbackError) {
+        }
+      }
+    }
+  }
+  async sendErrorBatchBeacon(batch) {
+    if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+      try {
+        const protobufData = this.encoder.encodeErrorBatch(batch);
+        const blob = new Blob([protobufData], { type: "application/x-protobuf" });
+        const url = `${this.config.endpoint}/api/v1/errors/ingest?api_key=${encodeURIComponent(this.config.apiKey)}`;
+        navigator.sendBeacon(url, blob);
+      } catch (error) {
+        if (this.config.debug) {
+          console.error("[ExperienceSDK] Error beacon send error:", error);
+        }
+        try {
+          const jsonBlob = new Blob([JSON.stringify(batch)], { type: "application/json" });
+          const jsonUrl = `${this.config.endpoint}/api/v1/errors/ingest/json?api_key=${encodeURIComponent(this.config.apiKey)}`;
+          navigator.sendBeacon(jsonUrl, jsonBlob);
+        } catch (fallbackError) {
+        }
+      }
+    }
+  }
+  async fetchFlags(appId, profileId) {
+    try {
+      const queryParams = new URLSearchParams();
+      if (profileId) {
+        queryParams.set("profileId", profileId);
+      }
+      const url = `${this.config.endpoint}/api/v1/flags/${appId}/resolve${queryParams.toString() ? "?" + queryParams.toString() : ""}`;
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "X-API-Key": this.config.apiKey
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const result = await response.json();
+      return result.flags || {};
+    } catch (error) {
+      if (this.config.debug) {
+        console.error("[ExperienceSDK] Flag fetch error:", error);
+      }
+      return {};
+    }
+  }
+};
+
+// src/batch.ts
+var EventBatcher = class {
+  constructor(transport, batchIntervalMs = 2e3, maxBatchSize = 50, debug = false) {
+    this.trackEvents = [];
+    this.heatmapEvents = [];
+    this.errorEvents = [];
+    this.flushTimer = null;
+    this.unsubscribeFns = [];
+    this.transport = transport;
+    this.batchIntervalMs = batchIntervalMs;
+    this.maxBatchSize = maxBatchSize;
+    this.debug = debug;
+    this.setupAutoFlush();
+    this.setupUnloadHandler();
+  }
+  setupAutoFlush() {
+    this.scheduleNextFlush();
+  }
+  scheduleNextFlush() {
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flushTimer = window.setTimeout(() => {
+      this.flush();
+      this.scheduleNextFlush();
+    }, this.batchIntervalMs);
+  }
+  setupUnloadHandler() {
+    if (typeof window === "undefined") return;
+    const handleUnload = () => {
+      this.flushBeacon();
+    };
+    window.addEventListener("beforeunload", handleUnload);
+    window.addEventListener("unload", handleUnload);
+    window.addEventListener("pagehide", handleUnload);
+    if (typeof document !== "undefined") {
+      const handleVisibilityChange = () => {
+        if (document.visibilityState === "hidden") {
+          this.flushBeacon();
+        }
+      };
+      document.addEventListener("visibilitychange", handleVisibilityChange);
+      this.unsubscribeFns.push(() => {
+        window.removeEventListener("beforeunload", handleUnload);
+        window.removeEventListener("unload", handleUnload);
+        window.removeEventListener("pagehide", handleUnload);
+        document.removeEventListener("visibilitychange", handleVisibilityChange);
+      });
+    } else {
+      this.unsubscribeFns.push(() => {
+        window.removeEventListener("beforeunload", handleUnload);
+        window.removeEventListener("unload", handleUnload);
+        window.removeEventListener("pagehide", handleUnload);
+      });
+    }
+  }
+  addTrackEvent(event) {
+    this.trackEvents.push(event);
+    if (this.debug) {
+      console.log("[ExperienceSDK] Track event added:", event);
+    }
+    if (this.trackEvents.length + this.heatmapEvents.length >= this.maxBatchSize) {
+      this.flush();
+    }
+  }
+  addHeatmapEvent(event) {
+    this.heatmapEvents.push(event);
+    if (this.debug) {
+      console.log("[ExperienceSDK] Heatmap event added:", event);
+    }
+    if (this.trackEvents.length + this.heatmapEvents.length >= this.maxBatchSize) {
+      this.flush();
+    }
+  }
+  addErrorEvent(error) {
+    this.errorEvents.push(error);
+    if (this.debug) {
+      console.log("[ExperienceSDK] Error event added:", error);
+    }
+    if (error.severity >= 2) {
+      this.flushErrors();
+    } else if (this.errorEvents.length >= this.maxBatchSize) {
+      this.flushErrors();
+    }
+  }
+  async flush() {
+    if (this.trackEvents.length === 0 && this.heatmapEvents.length === 0) {
+      return;
+    }
+    const batch = {
+      events: [...this.trackEvents],
+      heatmapEvents: [...this.heatmapEvents]
+    };
+    this.trackEvents = [];
+    this.heatmapEvents = [];
+    try {
+      const result = await this.transport.sendEventBatch(batch);
+      if (this.debug) {
+        console.log("[ExperienceSDK] Event batch sent successfully:", result);
+      }
+    } catch (error) {
+      if (this.debug) {
+        console.error("[ExperienceSDK] Failed to send event batch:", error);
+      }
+      this.trackEvents.unshift(...batch.events);
+      this.heatmapEvents.unshift(...batch.heatmapEvents);
+      this.trackEvents = this.trackEvents.slice(0, this.maxBatchSize * 2);
+      this.heatmapEvents = this.heatmapEvents.slice(0, this.maxBatchSize * 2);
+    }
+  }
+  async flushErrors() {
+    if (this.errorEvents.length === 0) {
+      return;
+    }
+    const batch = {
+      errors: [...this.errorEvents]
+    };
+    this.errorEvents = [];
+    try {
+      const result = await this.transport.sendErrorBatch(batch);
+      if (this.debug) {
+        console.log("[ExperienceSDK] Error batch sent successfully:", result);
+      }
+    } catch (error) {
+      if (this.debug) {
+        console.error("[ExperienceSDK] Failed to send error batch:", error);
+      }
+      this.errorEvents.unshift(...batch.errors);
+      this.errorEvents = this.errorEvents.slice(0, this.maxBatchSize * 2);
+    }
+  }
+  flushBeacon() {
+    if (this.trackEvents.length > 0 || this.heatmapEvents.length > 0) {
+      const eventBatch = {
+        events: [...this.trackEvents],
+        heatmapEvents: [...this.heatmapEvents]
+      };
+      this.transport.sendEventBatchBeacon(eventBatch);
+      this.trackEvents = [];
+      this.heatmapEvents = [];
+    }
+    if (this.errorEvents.length > 0) {
+      const errorBatch = {
+        errors: [...this.errorEvents]
+      };
+      this.transport.sendErrorBatchBeacon(errorBatch);
+      this.errorEvents = [];
+    }
+  }
+  getPendingEventCount() {
+    return this.trackEvents.length + this.heatmapEvents.length;
+  }
+  getPendingErrorCount() {
+    return this.errorEvents.length;
+  }
+  async shutdown() {
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.unsubscribeFns.forEach((fn) => fn());
+    this.unsubscribeFns = [];
+    await Promise.all([
+      this.flush(),
+      this.flushErrors()
+    ]);
+  }
+  // Force immediate flush for testing/debugging
+  async forceFlush() {
+    await Promise.all([
+      this.flush(),
+      this.flushErrors()
+    ]);
+  }
+};
+
 // src/breadcrumbs.ts
 var MAX_BREADCRUMBS = 50;
 var BreadcrumbManager = class {
   constructor() {
-    this.buffer = [];
+    this.breadcrumbs = [];
+    this.unsubscribeFns = [];
+    this.originalConsole = null;
     this.originalFetch = null;
-    this.originalXhrOpen = null;
-    this.clickHandler = null;
+    this.isEnabled = false;
+  }
+  enable() {
+    if (this.isEnabled) return;
+    this.isEnabled = true;
+    this.setupConsoleWrapping();
+    this.setupFetchWrapping();
+    this.setupXHRWrapping();
+    this.setupNavigationListeners();
+    this.setupClickListener();
+  }
+  disable() {
+    if (!this.isEnabled) return;
+    this.isEnabled = false;
+    this.unsubscribeFns.forEach((fn) => fn());
+    this.unsubscribeFns = [];
+    this.restoreConsole();
+    this.restoreFetch();
+  }
+  addBreadcrumb(breadcrumb) {
+    const fullBreadcrumb = {
+      ...breadcrumb,
+      timestamp: Date.now()
+    };
+    this.breadcrumbs.push(fullBreadcrumb);
+    if (this.breadcrumbs.length > MAX_BREADCRUMBS) {
+      this.breadcrumbs = this.breadcrumbs.slice(-MAX_BREADCRUMBS);
+    }
+  }
+  setupConsoleWrapping() {
+    if (typeof console === "undefined") return;
     this.originalConsole = {
-      log: console.log,
       warn: console.warn,
       error: console.error
     };
+    console.warn = (...args) => {
+      this.addBreadcrumb({
+        category: "console",
+        message: args.map((arg) => String(arg)).join(" "),
+        level: "warning"
+      });
+      this.originalConsole.warn.apply(console, args);
+    };
+    console.error = (...args) => {
+      this.addBreadcrumb({
+        category: "console",
+        message: args.map((arg) => String(arg)).join(" "),
+        level: "error"
+      });
+      this.originalConsole.error.apply(console, args);
+    };
+  }
+  restoreConsole() {
+    if (this.originalConsole && typeof console !== "undefined") {
+      console.warn = this.originalConsole.warn;
+      console.error = this.originalConsole.error;
+      this.originalConsole = null;
+    }
+  }
+  setupFetchWrapping() {
+    if (typeof fetch === "undefined" || typeof window === "undefined") return;
+    this.originalFetch = window.fetch;
+    window.fetch = async (input, init) => {
+      const url = typeof input === "string" ? input : input.toString();
+      const method = init?.method || "GET";
+      const startTime = Date.now();
+      try {
+        const response = await this.originalFetch(input, init);
+        const duration = Date.now() - startTime;
+        this.addBreadcrumb({
+          category: "fetch",
+          message: `${method} ${url}`,
+          data: {
+            url,
+            method,
+            status: response.status,
+            duration: `${duration}ms`
+          },
+          level: response.ok ? "info" : "error"
+        });
+        return response;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        this.addBreadcrumb({
+          category: "fetch",
+          message: `${method} ${url} (failed)`,
+          data: {
+            url,
+            method,
+            error: error instanceof Error ? error.message : String(error),
+            duration: `${duration}ms`
+          },
+          level: "error"
+        });
+        throw error;
+      }
+    };
+  }
+  restoreFetch() {
+    if (this.originalFetch && typeof window !== "undefined") {
+      window.fetch = this.originalFetch;
+      this.originalFetch = null;
+    }
+  }
+  setupXHRWrapping() {
+    if (typeof XMLHttpRequest === "undefined") return;
+    const originalOpen = XMLHttpRequest.prototype.open;
+    const originalSend = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.open = function(method, url, async, user, password) {
+      this.__method = method;
+      this.__url = url.toString();
+      this.__startTime = Date.now();
+      return originalOpen.apply(this, arguments);
+    };
+    XMLHttpRequest.prototype.send = function(body) {
+      const xhr = this;
+      const method = xhr.__method || "GET";
+      const url = xhr.__url || "";
+      const originalOnReadyStateChange = xhr.onreadystatechange;
+      xhr.onreadystatechange = function() {
+        if (xhr.readyState === 4) {
+          const startTime = xhr.__startTime || Date.now();
+          const duration = Date.now() - startTime;
+          const breadcrumbManager = globalThis.__experienceBreadcrumbs;
+          if (breadcrumbManager) {
+            breadcrumbManager.addBreadcrumb({
+              category: "xhr",
+              message: `${method} ${url}`,
+              data: {
+                url,
+                method,
+                status: xhr.status,
+                duration: `${duration}ms`
+              },
+              level: xhr.status >= 200 && xhr.status < 300 ? "info" : "error"
+            });
+          }
+        }
+        if (originalOnReadyStateChange) {
+          originalOnReadyStateChange.apply(xhr, arguments);
+        }
+      };
+      return originalSend.apply(this, arguments);
+    };
+    globalThis.__experienceBreadcrumbs = this;
+  }
+  setupNavigationListeners() {
+    if (typeof window === "undefined" || typeof history === "undefined") return;
+    const handlePopState = () => {
+      this.addBreadcrumb({
+        category: "navigation",
+        message: "Navigation (popstate)",
+        data: {
+          url: window.location.href,
+          type: "popstate"
+        }
+      });
+    };
+    window.addEventListener("popstate", handlePopState);
+    this.unsubscribeFns.push(() => window.removeEventListener("popstate", handlePopState));
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+    history.pushState = function(...args) {
+      const breadcrumbManager = globalThis.__experienceBreadcrumbs;
+      if (breadcrumbManager) {
+        breadcrumbManager.addBreadcrumb({
+          category: "navigation",
+          message: "Navigation (pushState)",
+          data: {
+            url: args[2] || window.location.href,
+            type: "pushState"
+          }
+        });
+      }
+      return originalPushState.apply(this, args);
+    };
+    history.replaceState = function(...args) {
+      const breadcrumbManager = globalThis.__experienceBreadcrumbs;
+      if (breadcrumbManager) {
+        breadcrumbManager.addBreadcrumb({
+          category: "navigation",
+          message: "Navigation (replaceState)",
+          data: {
+            url: args[2] || window.location.href,
+            type: "replaceState"
+          }
+        });
+      }
+      return originalReplaceState.apply(this, args);
+    };
+    this.unsubscribeFns.push(() => {
+      history.pushState = originalPushState;
+      history.replaceState = originalReplaceState;
+    });
+  }
+  setupClickListener() {
+    if (typeof document === "undefined") return;
+    const handleClick = (event) => {
+      const target = event.target;
+      if (!target) return;
+      const tagName = target.tagName?.toLowerCase();
+      const selector = this.getElementSelector(target);
+      this.addBreadcrumb({
+        category: "click",
+        message: `Click on ${tagName}`,
+        data: {
+          selector,
+          tag: tagName,
+          text: target.textContent?.slice(0, 100) || "",
+          x: event.clientX,
+          y: event.clientY
+        }
+      });
+    };
+    document.addEventListener("click", handleClick, true);
+    this.unsubscribeFns.push(() => document.removeEventListener("click", handleClick, true));
+  }
+  getElementSelector(element) {
+    try {
+      const tag = element.tagName.toLowerCase();
+      const id = element.id ? `#${element.id}` : "";
+      const className = element.className && typeof element.className === "string" ? `.${element.className.split(" ").filter((c) => c.trim()).join(".")}` : "";
+      return `${tag}${id}${className}`.slice(0, 100);
+    } catch {
+      return element.tagName?.toLowerCase() || "unknown";
+    }
+  }
+  getBreadcrumbs() {
+    return [...this.breadcrumbs];
+  }
+  clear() {
+    this.breadcrumbs = [];
+  }
+  addCustomBreadcrumb(category, message, data) {
+    this.addBreadcrumb({
+      category,
+      message,
+      data
+    });
+  }
+};
+
+// src/heatmap.ts
+var MOUSEMOVE_THROTTLE_MS = 100;
+var HOVER_THRESHOLD_MS = 500;
+var HeatmapTracker = class {
+  constructor(batcher, sessionId) {
+    this.isEnabled = false;
+    this.unsubscribeFns = [];
+    this.lastMouseMoveTime = 0;
+    this.hoverTimer = null;
+    this.lastHoverPosition = null;
+    this.batcher = batcher;
+    this.sessionId = sessionId;
+  }
+  enable() {
+    if (this.isEnabled || typeof document === "undefined") return;
+    this.isEnabled = true;
+    this.setupMouseMoveTracking();
+    this.setupClickTracking();
+    this.setupHoverTracking();
+  }
+  disable() {
+    if (!this.isEnabled) return;
+    this.isEnabled = false;
+    if (this.hoverTimer !== null) {
+      clearTimeout(this.hoverTimer);
+      this.hoverTimer = null;
+    }
+    this.unsubscribeFns.forEach((fn) => fn());
+    this.unsubscribeFns = [];
+  }
+  setupMouseMoveTracking() {
+    const handleMouseMove = (event) => {
+      const now = Date.now();
+      if (now - this.lastMouseMoveTime < MOUSEMOVE_THROTTLE_MS) {
+        return;
+      }
+      this.lastMouseMoveTime = now;
+      const viewport = this.getViewportSize();
+      const heatmapEvent = {
+        sessionId: this.sessionId,
+        timestamp: now,
+        type: "move",
+        x: event.clientX,
+        y: event.clientY,
+        viewportWidth: viewport.width,
+        viewportHeight: viewport.height,
+        url: window.location.href
+      };
+      this.batcher.addHeatmapEvent(heatmapEvent);
+    };
+    document.addEventListener("mousemove", handleMouseMove, { passive: true });
+    this.unsubscribeFns.push(
+      () => document.removeEventListener("mousemove", handleMouseMove)
+    );
+  }
+  setupClickTracking() {
+    const handleClick = (event) => {
+      const viewport = this.getViewportSize();
+      const heatmapEvent = {
+        sessionId: this.sessionId,
+        timestamp: Date.now(),
+        type: "click",
+        x: event.clientX,
+        y: event.clientY,
+        viewportWidth: viewport.width,
+        viewportHeight: viewport.height,
+        url: window.location.href
+      };
+      this.batcher.addHeatmapEvent(heatmapEvent);
+    };
+    document.addEventListener("click", handleClick, { passive: true });
+    this.unsubscribeFns.push(
+      () => document.removeEventListener("click", handleClick)
+    );
+  }
+  setupHoverTracking() {
+    const handleMouseEnter = (event) => {
+      const x = event.clientX;
+      const y = event.clientY;
+      this.lastHoverPosition = { x, y };
+      this.hoverTimer = window.setTimeout(() => {
+        if (this.lastHoverPosition && Math.abs(this.lastHoverPosition.x - x) < 50 && Math.abs(this.lastHoverPosition.y - y) < 50) {
+          const viewport = this.getViewportSize();
+          const heatmapEvent = {
+            sessionId: this.sessionId,
+            timestamp: Date.now(),
+            type: "hover",
+            x: this.lastHoverPosition.x,
+            y: this.lastHoverPosition.y,
+            viewportWidth: viewport.width,
+            viewportHeight: viewport.height,
+            url: window.location.href
+          };
+          this.batcher.addHeatmapEvent(heatmapEvent);
+        }
+      }, HOVER_THRESHOLD_MS);
+    };
+    const handleMouseMove = (event) => {
+      this.lastHoverPosition = { x: event.clientX, y: event.clientY };
+    };
+    const handleMouseLeave = () => {
+      if (this.hoverTimer !== null) {
+        clearTimeout(this.hoverTimer);
+        this.hoverTimer = null;
+      }
+      this.lastHoverPosition = null;
+    };
+    let lastHoverMoveTime = 0;
+    const throttledMouseMove = (event) => {
+      const now = Date.now();
+      if (now - lastHoverMoveTime >= 100) {
+        lastHoverMoveTime = now;
+        handleMouseMove(event);
+      }
+    };
+    document.addEventListener("mouseenter", handleMouseEnter, { passive: true });
+    document.addEventListener("mousemove", throttledMouseMove, { passive: true });
+    document.addEventListener("mouseleave", handleMouseLeave, { passive: true });
+    this.unsubscribeFns.push(() => {
+      document.removeEventListener("mouseenter", handleMouseEnter);
+      document.removeEventListener("mousemove", throttledMouseMove);
+      document.removeEventListener("mouseleave", handleMouseLeave);
+    });
+  }
+  getViewportSize() {
+    if (typeof window === "undefined") {
+      return { width: 1920, height: 1080 };
+    }
+    return {
+      width: window.innerWidth || document.documentElement.clientWidth || 1920,
+      height: window.innerHeight || document.documentElement.clientHeight || 1080
+    };
+  }
+  updateSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  // Manual event tracking for programmatic use
+  trackClick(x, y) {
+    if (!this.isEnabled) return;
+    const viewport = this.getViewportSize();
+    const heatmapEvent = {
+      sessionId: this.sessionId,
+      timestamp: Date.now(),
+      type: "click",
+      x: Math.round(x),
+      y: Math.round(y),
+      viewportWidth: viewport.width,
+      viewportHeight: viewport.height,
+      url: window.location.href
+    };
+    this.batcher.addHeatmapEvent(heatmapEvent);
+  }
+  trackHover(x, y) {
+    if (!this.isEnabled) return;
+    const viewport = this.getViewportSize();
+    const heatmapEvent = {
+      sessionId: this.sessionId,
+      timestamp: Date.now(),
+      type: "hover",
+      x: Math.round(x),
+      y: Math.round(y),
+      viewportWidth: viewport.width,
+      viewportHeight: viewport.height,
+      url: window.location.href
+    };
+    this.batcher.addHeatmapEvent(heatmapEvent);
+  }
+};
+
+// src/errors.ts
+var ErrorCapture = class {
+  constructor(batcher, breadcrumbManager, sessionId) {
+    this.isEnabled = false;
+    this.unsubscribeFns = [];
+    this.originalWindowError = null;
+    this.originalUnhandledRejection = null;
+    this.batcher = batcher;
+    this.breadcrumbManager = breadcrumbManager;
+    this.sessionId = sessionId;
+  }
+  enable() {
+    if (this.isEnabled || typeof window === "undefined") return;
+    this.isEnabled = true;
+    this.setupGlobalErrorHandler();
+    this.setupUnhandledRejectionHandler();
+  }
+  disable() {
+    if (!this.isEnabled) return;
+    this.isEnabled = false;
+    this.restoreOriginalHandlers();
+    this.unsubscribeFns.forEach((fn) => fn());
+    this.unsubscribeFns = [];
+  }
+  setupGlobalErrorHandler() {
+    this.originalWindowError = window.onerror;
+    window.onerror = (message, filename, lineno, colno, error) => {
+      this.captureError({
+        message: typeof message === "string" ? message : "Unknown error",
+        filename,
+        lineno,
+        colno,
+        stack: error?.stack,
+        severity: 2 /* ERROR */
+      });
+      if (this.originalWindowError) {
+        return this.originalWindowError.call(window, message, filename, lineno, colno, error);
+      }
+      return false;
+    };
+  }
+  setupUnhandledRejectionHandler() {
+    const handleUnhandledRejection = (event) => {
+      let message = "Unhandled Promise Rejection";
+      let stack;
+      if (event.reason) {
+        if (event.reason instanceof Error) {
+          message = event.reason.message || "Unhandled Promise Rejection";
+          stack = event.reason.stack;
+        } else if (typeof event.reason === "string") {
+          message = event.reason;
+        } else {
+          try {
+            message = JSON.stringify(event.reason);
+          } catch {
+            message = "Unhandled Promise Rejection (non-serializable reason)";
+          }
+        }
+      }
+      this.captureError({
+        message,
+        stack,
+        severity: 2 /* ERROR */
+      });
+      if (this.originalUnhandledRejection) {
+        this.originalUnhandledRejection.call(window, event);
+      }
+    };
+    this.originalUnhandledRejection = window.onunhandledrejection;
+    window.addEventListener("unhandledrejection", handleUnhandledRejection);
+    this.unsubscribeFns.push(() => {
+      window.removeEventListener("unhandledrejection", handleUnhandledRejection);
+    });
+  }
+  restoreOriginalHandlers() {
+    if (typeof window !== "undefined") {
+      if (this.originalWindowError !== null) {
+        window.onerror = this.originalWindowError;
+        this.originalWindowError = null;
+      }
+      if (this.originalUnhandledRejection !== null) {
+        window.onunhandledrejection = this.originalUnhandledRejection;
+        this.originalUnhandledRejection = null;
+      }
+    }
+  }
+  getBrowserContext() {
+    return {
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "Unknown",
+      url: typeof window !== "undefined" ? window.location.href : "Unknown",
+      timestamp: Date.now(),
+      viewport: {
+        width: typeof window !== "undefined" ? window.innerWidth || 1920 : 1920,
+        height: typeof window !== "undefined" ? window.innerHeight || 1080 : 1080
+      }
+    };
+  }
+  captureError(errorData) {
+    const errorEvent = {
+      sessionId: this.sessionId,
+      timestamp: Date.now(),
+      message: errorData.message,
+      filename: errorData.filename,
+      lineno: errorData.lineno,
+      colno: errorData.colno,
+      stack: errorData.stack,
+      severity: errorData.severity,
+      breadcrumbs: this.breadcrumbManager.getBreadcrumbs(),
+      browserContext: this.getBrowserContext(),
+      tags: errorData.tags,
+      extra: errorData.extra
+    };
+    this.batcher.addErrorEvent(errorEvent);
+    this.breadcrumbManager.addCustomBreadcrumb("ui", `Error: ${errorData.message}`, {
+      severity: Severity[errorData.severity].toLowerCase(),
+      filename: errorData.filename,
+      line: errorData.lineno
+    });
+  }
+  // Public methods for manual error reporting
+  captureException(error, options) {
+    if (!this.isEnabled) return;
+    const severity = options?.severity ?? 2 /* ERROR */;
+    this.captureError({
+      message: error.message || "Unknown error",
+      stack: error.stack,
+      severity,
+      tags: options?.tags,
+      extra: options?.extra
+    });
+  }
+  captureMessage(message, severity = 0 /* INFO */, options) {
+    if (!this.isEnabled) return;
+    this.captureError({
+      message,
+      severity,
+      tags: options?.tags,
+      extra: options?.extra
+    });
+  }
+  captureBreadcrumb(message, category = "ui", data) {
+    this.breadcrumbManager.addCustomBreadcrumb(category, message, data);
+  }
+  updateSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  // Utility method to extract error info from various error types
+  extractErrorInfo(error) {
+    if (error instanceof Error) {
+      return {
+        message: error.message || "Unknown error",
+        stack: error.stack
+      };
+    }
+    if (typeof error === "string") {
+      return { message: error };
+    }
+    if (error && typeof error === "object") {
+      try {
+        return { message: JSON.stringify(error) };
+      } catch {
+        return { message: "Non-serializable error object" };
+      }
+    }
+    return { message: "Unknown error type" };
+  }
+  // Helper method for severity string to enum conversion
+  static getSeverityFromString(severity) {
+    switch (severity.toLowerCase()) {
+      case "info":
+        return 0 /* INFO */;
+      case "warning":
+      case "warn":
+        return 1 /* WARNING */;
+      case "error":
+        return 2 /* ERROR */;
+      case "fatal":
+        return 3 /* FATAL */;
+      default:
+        return 0 /* INFO */;
+    }
+  }
+  // Test method for manual error triggering (useful for debugging)
+  triggerTestError() {
+    if (!this.isEnabled) return;
+    try {
+      throw new Error("Test error from ExperienceSDK");
+    } catch (error) {
+      this.captureException(error, {
+        tags: { test: "true" },
+        severity: 1 /* WARNING */
+      });
+    }
+  }
+};
+
+// src/auto-track.ts
+var AutoTracker = class {
+  constructor(batcher, sessionId) {
+    this.isEnabled = false;
+    this.unsubscribeFns = [];
+    this.lastUrl = null;
+    this.pageLoadTime = Date.now();
+    this.batcher = batcher;
+    this.sessionId = sessionId;
+  }
+  enable() {
+    if (this.isEnabled) return;
+    this.isEnabled = true;
+    this.trackInitialPageView();
+    this.setupSPATracking();
+  }
+  disable() {
+    if (!this.isEnabled) return;
+    this.isEnabled = false;
+    this.unsubscribeFns.forEach((fn) => fn());
+    this.unsubscribeFns = [];
+  }
+  trackInitialPageView() {
+    if (typeof window === "undefined") return;
+    const loadTime = this.calculateLoadTime();
+    this.trackPageView(loadTime);
+    this.lastUrl = window.location.href;
+  }
+  calculateLoadTime() {
+    if (typeof performance === "undefined" || !performance.timing) {
+      return void 0;
+    }
+    const timing = performance.timing;
+    if (timing.loadEventEnd && timing.navigationStart) {
+      return timing.loadEventEnd - timing.navigationStart;
+    }
+    if (timing.domContentLoadedEventEnd && timing.navigationStart) {
+      return timing.domContentLoadedEventEnd - timing.navigationStart;
+    }
+    return void 0;
+  }
+  setupSPATracking() {
+    if (typeof window === "undefined" || typeof history === "undefined") return;
+    const handlePopState = () => {
+      setTimeout(() => {
+        if (window.location.href !== this.lastUrl) {
+          this.trackPageView();
+          this.lastUrl = window.location.href;
+        }
+      }, 0);
+    };
+    window.addEventListener("popstate", handlePopState);
+    this.unsubscribeFns.push(() => window.removeEventListener("popstate", handlePopState));
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+    history.pushState = (...args) => {
+      const result = originalPushState.apply(history, args);
+      setTimeout(() => {
+        if (window.location.href !== this.lastUrl) {
+          this.trackPageView();
+          this.lastUrl = window.location.href;
+        }
+      }, 0);
+      return result;
+    };
+    history.replaceState = (...args) => {
+      const result = originalReplaceState.apply(history, args);
+      setTimeout(() => {
+        if (window.location.href !== this.lastUrl) {
+          this.trackPageView();
+          this.lastUrl = window.location.href;
+        }
+      }, 0);
+      return result;
+    };
+    this.unsubscribeFns.push(() => {
+      history.pushState = originalPushState;
+      history.replaceState = originalReplaceState;
+    });
+  }
+  getPageContext(loadTime) {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return {
+        url: "unknown",
+        title: "unknown",
+        referrer: "",
+        viewport: { width: 1920, height: 1080 }
+      };
+    }
+    return {
+      url: window.location.href,
+      title: document.title || "",
+      referrer: document.referrer || "",
+      viewport: {
+        width: window.innerWidth || document.documentElement.clientWidth || 1920,
+        height: window.innerHeight || document.documentElement.clientHeight || 1080
+      },
+      loadTime
+    };
+  }
+  trackPageView(loadTime) {
+    const pageContext = this.getPageContext(loadTime);
+    const trackEvent = {
+      eventType: "page_view",
+      sessionId: this.sessionId,
+      timestamp: Date.now(),
+      pageContext
+    };
+    this.batcher.addTrackEvent(trackEvent);
+  }
+  // Public method for manual page view tracking
+  trackCurrentPage() {
+    if (!this.isEnabled) return;
+    this.trackPageView();
+    if (typeof window !== "undefined") {
+      this.lastUrl = window.location.href;
+    }
+  }
+  // Track custom navigation events
+  trackNavigation(eventType, metadata) {
+    if (!this.isEnabled) return;
+    const pageContext = this.getPageContext();
+    const trackEvent = {
+      eventType,
+      sessionId: this.sessionId,
+      timestamp: Date.now(),
+      pageContext,
+      metadata
+    };
+    this.batcher.addTrackEvent(trackEvent);
+  }
+  updateSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  // Get current page info for debugging
+  getCurrentPageInfo() {
+    return this.getPageContext();
+  }
+};
+
+// src/data-t.ts
+var HOVER_THRESHOLD_MS2 = 500;
+var DataTTracker = class {
+  constructor(batcher, sessionId) {
+    this.isEnabled = false;
+    this.unsubscribeFns = [];
+    this.mutationObserver = null;
+    this.intersectionObserver = null;
+    this.visibleElements = /* @__PURE__ */ new Set();
+    this.hoverTimers = /* @__PURE__ */ new Map();
+    this.batcher = batcher;
+    this.sessionId = sessionId;
   }
-  add(breadcrumb) {
-    this.buffer.push({ ...breadcrumb, timestampMs: Date.now() });
-    if (this.buffer.length > MAX_BREADCRUMBS) {
-      this.buffer.shift();
+  enable() {
+    if (this.isEnabled || typeof document === "undefined") return;
+    this.isEnabled = true;
+    this.setupMutationObserver();
+    this.setupEventDelegation();
+    this.setupVisibilityTracking();
+    this.setupHoverTracking();
+    this.scanExistingElements();
+  }
+  disable() {
+    if (!this.isEnabled) return;
+    this.isEnabled = false;
+    if (this.mutationObserver) {
+      this.mutationObserver.disconnect();
+      this.mutationObserver = null;
+    }
+    if (this.intersectionObserver) {
+      this.intersectionObserver.disconnect();
+      this.intersectionObserver = null;
     }
+    this.hoverTimers.forEach((timer) => clearTimeout(timer));
+    this.hoverTimers.clear();
+    this.unsubscribeFns.forEach((fn) => fn());
+    this.unsubscribeFns = [];
+    this.visibleElements.clear();
+  }
+  setupMutationObserver() {
+    if (typeof MutationObserver === "undefined") return;
+    this.mutationObserver = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        if (mutation.type === "childList") {
+          mutation.addedNodes.forEach((node) => {
+            if (node.nodeType === Node.ELEMENT_NODE) {
+              const element = node;
+              this.processNewElement(element);
+              const descendants = element.querySelectorAll("[data-t]");
+              descendants.forEach((desc) => this.processNewElement(desc));
+            }
+          });
+        } else if (mutation.type === "attributes" && mutation.attributeName === "data-t") {
+          const target = mutation.target;
+          this.processNewElement(target);
+        }
+      }
+    });
+    this.mutationObserver.observe(document, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["data-t"]
+    });
   }
-  getAll() {
-    return [...this.buffer];
+  setupEventDelegation() {
+    const handleClick = (event) => {
+      const target = event.target;
+      if (!target) return;
+      const dataTElement = this.findDataTParent(target);
+      if (dataTElement) {
+        this.trackDataTEvent("click", dataTElement, {
+          x: event.clientX,
+          y: event.clientY
+        });
+      }
+    };
+    document.addEventListener("click", handleClick, true);
+    this.unsubscribeFns.push(
+      () => document.removeEventListener("click", handleClick, true)
+    );
   }
-  install() {
-    ["log", "warn", "error"].forEach((level) => {
-      const original = this.originalConsole[level];
-      console[level] = (...args) => {
-        this.add({
-          type: "console",
-          category: level,
-          message: args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")
+  setupVisibilityTracking() {
+    if (typeof IntersectionObserver === "undefined") return;
+    this.intersectionObserver = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          const element = entry.target;
+          const dataTValue = element.getAttribute("data-t");
+          if (!dataTValue) return;
+          if (entry.isIntersecting && !this.visibleElements.has(element)) {
+            this.visibleElements.add(element);
+            this.trackDataTEvent("view", element);
+          } else if (!entry.isIntersecting && this.visibleElements.has(element)) {
+            this.visibleElements.delete(element);
+            this.trackDataTEvent("hide", element);
+          }
         });
-        original.apply(console, args);
-      };
+      },
+      {
+        threshold: 0.1,
+        // Trigger when at least 10% visible
+        rootMargin: "50px"
+        // Start observing 50px before entering viewport
+      }
+    );
+  }
+  setupHoverTracking() {
+    const handleMouseEnter = (event) => {
+      const target = event.target;
+      const dataTElement = this.findDataTParent(target);
+      if (!dataTElement) return;
+      const timer = window.setTimeout(() => {
+        this.trackDataTEvent("hover", dataTElement);
+        this.hoverTimers.delete(dataTElement);
+      }, HOVER_THRESHOLD_MS2);
+      this.hoverTimers.set(dataTElement, timer);
+    };
+    const handleMouseLeave = (event) => {
+      const target = event.target;
+      const dataTElement = this.findDataTParent(target);
+      if (!dataTElement) return;
+      const timer = this.hoverTimers.get(dataTElement);
+      if (timer) {
+        clearTimeout(timer);
+        this.hoverTimers.delete(dataTElement);
+      }
+    };
+    document.addEventListener("mouseenter", handleMouseEnter, true);
+    document.addEventListener("mouseleave", handleMouseLeave, true);
+    this.unsubscribeFns.push(() => {
+      document.removeEventListener("mouseenter", handleMouseEnter, true);
+      document.removeEventListener("mouseleave", handleMouseLeave, true);
     });
-    if (typeof fetch !== "undefined") {
-      this.originalFetch = fetch;
-      const self = this;
-      window.fetch = function(input, init) {
-        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-        const method = init?.method || "GET";
-        self.add({ type: "http", category: "fetch", message: `${method} ${url}` });
-        return self.originalFetch.call(window, input, init);
-      };
+  }
+  scanExistingElements() {
+    const existingElements = document.querySelectorAll("[data-t]");
+    existingElements.forEach((element) => this.processNewElement(element));
+  }
+  processNewElement(element) {
+    const dataTValue = element.getAttribute("data-t");
+    if (!dataTValue) return;
+    if (this.intersectionObserver) {
+      this.intersectionObserver.observe(element);
+    }
+    this.trackDataTEvent("discover", element);
+  }
+  findDataTParent(element) {
+    let current = element;
+    while (current) {
+      if (current.hasAttribute("data-t")) {
+        return current;
+      }
+      current = current.parentElement;
+    }
+    return null;
+  }
+  getElementSelector(element) {
+    try {
+      const tag = element.tagName.toLowerCase();
+      const id = element.id ? `#${element.id}` : "";
+      const classes = element.className && typeof element.className === "string" ? `.${element.className.split(" ").filter((c) => c.trim()).join(".")}` : "";
+      let selector = `${tag}${id}${classes}`;
+      const parent = element.parentElement;
+      if (parent && !id) {
+        const siblings = Array.from(parent.children).filter(
+          (child) => child.tagName === element.tagName
+        );
+        if (siblings.length > 1) {
+          const index = siblings.indexOf(element) + 1;
+          selector += `:nth-child(${index})`;
+        }
+      }
+      return selector.slice(0, 200);
+    } catch (error) {
+      return element.tagName?.toLowerCase() || "unknown";
     }
-    if (typeof XMLHttpRequest !== "undefined") {
-      this.originalXhrOpen = XMLHttpRequest.prototype.open;
-      const self = this;
-      XMLHttpRequest.prototype.open = function(method, url) {
-        self.add({ type: "http", category: "xhr", message: `${method} ${url}` });
-        return self.originalXhrOpen.apply(this, arguments);
+  }
+  getElementContext(element, position) {
+    return {
+      selector: this.getElementSelector(element),
+      dataT: element.getAttribute("data-t") || void 0,
+      tag: element.tagName.toLowerCase(),
+      position
+    };
+  }
+  getPageContext() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return {
+        url: "unknown",
+        title: "unknown",
+        referrer: "",
+        viewport: { width: 1920, height: 1080 }
       };
     }
-    this.clickHandler = (e) => {
-      const target = e.target;
-      if (!target) return;
-      const tag = target.tagName?.toLowerCase() || "";
-      const text = (target.textContent || "").slice(0, 100);
-      this.add({ type: "ui", category: "click", message: `${tag}: ${text}` });
+    return {
+      url: window.location.href,
+      title: document.title || "",
+      referrer: document.referrer || "",
+      viewport: {
+        width: window.innerWidth || 1920,
+        height: window.innerHeight || 1080
+      }
     };
-    document.addEventListener("click", this.clickHandler, true);
   }
-  teardown() {
-    console.log = this.originalConsole.log;
-    console.warn = this.originalConsole.warn;
-    console.error = this.originalConsole.error;
-    if (this.originalFetch) {
-      window.fetch = this.originalFetch;
+  trackDataTEvent(eventType, element, position) {
+    const dataTValue = element.getAttribute("data-t");
+    if (!dataTValue) return;
+    const elementContext = this.getElementContext(element, position);
+    const pageContext = this.getPageContext();
+    const trackEvent = {
+      eventType: `data_t_${eventType}`,
+      sessionId: this.sessionId,
+      timestamp: Date.now(),
+      pageContext,
+      elementContext,
+      metadata: {
+        data_t: dataTValue,
+        event_type: eventType
+      }
+    };
+    this.batcher.addTrackEvent(trackEvent);
+  }
+  updateSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+};
+
+// src/flags.ts
+var FeatureFlagClient = class {
+  constructor(transport, appId, debug = false) {
+    this.profileId = null;
+    this.flagCache = /* @__PURE__ */ new Map();
+    this.cacheTimeoutMs = 5 * 60 * 1e3;
+    // 5 minutes
+    this.eventSource = null;
+    this._backgroundFetchInProgress = false;
+    this.transport = transport;
+    this.appId = appId;
+    this.debug = debug;
+  }
+  setProfileId(profileId) {
+    this.profileId = profileId;
+    this.flagCache.clear();
+  }
+  async fetchFlags() {
+    try {
+      const flags = await this.transport.fetchFlags(this.appId, this.profileId || void 0);
+      const now = Date.now();
+      for (const [key, value] of Object.entries(flags)) {
+        this.flagCache.set(key, {
+          value,
+          fetchedAt: now
+        });
+      }
+      if (this.debug) {
+        console.log("[ExperienceSDK] Flags fetched:", flags);
+      }
+    } catch (error) {
+      if (this.debug) {
+        console.error("[ExperienceSDK] Failed to fetch flags:", error);
+      }
+    }
+  }
+  getFlag(key, defaultValue) {
+    const cached = this.flagCache.get(key);
+    if (cached && Date.now() - cached.fetchedAt < this.cacheTimeoutMs) {
+      if (this.debug) {
+        console.log(`[ExperienceSDK] Flag '${key}' from cache:`, cached.value);
+      }
+      return this.convertValue(cached.value, defaultValue, key);
+    }
+    this.fetchFlagsInBackground();
+    if (this.debug) {
+      console.log(`[ExperienceSDK] Flag '${key}' not in cache, returning default:`, defaultValue);
+    }
+    return defaultValue;
+  }
+  getFlagSync(key, defaultValue) {
+    const cached = this.flagCache.get(key);
+    if (cached) {
+      return this.convertValue(cached.value, defaultValue, key);
+    }
+    return defaultValue;
+  }
+  convertValue(value, defaultValue, key) {
+    try {
+      if (typeof value === typeof defaultValue) {
+        return value;
+      }
+      if (typeof defaultValue === "boolean") {
+        if (typeof value === "string") {
+          return value.toLowerCase() === "true" || value === "1";
+        }
+        return Boolean(value);
+      }
+      if (typeof defaultValue === "number") {
+        const num = Number(value);
+        return isNaN(num) ? defaultValue : num;
+      }
+      if (typeof defaultValue === "string") {
+        return String(value);
+      }
+      if (typeof defaultValue === "object" && typeof value === "string") {
+        try {
+          return JSON.parse(value);
+        } catch {
+          return defaultValue;
+        }
+      }
+      return value;
+    } catch (error) {
+      if (this.debug) {
+        console.warn(`[ExperienceSDK] Failed to convert flag value for '${key}':`, error);
+      }
+      return defaultValue;
+    }
+  }
+  fetchFlagsInBackground() {
+    if (this._backgroundFetchInProgress) {
+      return;
+    }
+    this._backgroundFetchInProgress = true;
+    this.fetchFlags().finally(() => {
+      this._backgroundFetchInProgress = false;
+    });
+  }
+  // Initialize with immediate fetch
+  async initialize() {
+    await this.fetchFlags();
+  }
+  // Set up real-time flag updates via Server-Sent Events
+  setupRealtimeUpdates(endpoint) {
+    if (typeof EventSource === "undefined") {
+      if (this.debug) {
+        console.warn("[ExperienceSDK] EventSource not supported, real-time flag updates disabled");
+      }
+      return;
+    }
+    this.closeRealtimeUpdates();
+    const baseEndpoint = endpoint || this.transport["config"].endpoint;
+    const streamUrl = `${baseEndpoint}/api/v1/flags/${this.appId}/resolve/stream`;
+    const url = new URL(streamUrl);
+    if (this.profileId) {
+      url.searchParams.set("profileId", this.profileId);
+    }
+    try {
+      this.eventSource = new EventSource(url.toString());
+      this.eventSource.onopen = () => {
+        if (this.debug) {
+          console.log("[ExperienceSDK] Real-time flag updates connected");
+        }
+      };
+      this.eventSource.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          if (data.flags) {
+            const now = Date.now();
+            for (const [key, value] of Object.entries(data.flags)) {
+              this.flagCache.set(key, {
+                value,
+                fetchedAt: now
+              });
+            }
+            if (this.debug) {
+              console.log("[ExperienceSDK] Flag updates received:", data.flags);
+            }
+          }
+        } catch (error) {
+          if (this.debug) {
+            console.error("[ExperienceSDK] Failed to parse flag update:", error);
+          }
+        }
+      };
+      this.eventSource.onerror = (error) => {
+        if (this.debug) {
+          console.error("[ExperienceSDK] Real-time flag updates error:", error);
+        }
+        setTimeout(() => {
+          if (this.eventSource?.readyState === EventSource.CLOSED) {
+            this.setupRealtimeUpdates(endpoint);
+          }
+        }, 5e3);
+      };
+    } catch (error) {
+      if (this.debug) {
+        console.error("[ExperienceSDK] Failed to setup real-time flag updates:", error);
+      }
+    }
+  }
+  closeRealtimeUpdates() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+      if (this.debug) {
+        console.log("[ExperienceSDK] Real-time flag updates disconnected");
+      }
+    }
+  }
+  // Clear all cached flags
+  clearCache() {
+    this.flagCache.clear();
+    if (this.debug) {
+      console.log("[ExperienceSDK] Flag cache cleared");
+    }
+  }
+  // Get cache status for debugging
+  getCacheInfo() {
+    const keys = Array.from(this.flagCache.keys());
+    const now = Date.now();
+    let oldestEntry;
+    let newestEntry;
+    for (const [cacheKey, entry] of this.flagCache.entries()) {
+      const age = now - entry.fetchedAt;
+      if (!oldestEntry || age > oldestEntry.age) {
+        oldestEntry = { key: cacheKey, age };
+      }
+      if (!newestEntry || age < newestEntry.age) {
+        newestEntry = { key: cacheKey, age };
+      }
     }
-    if (this.originalXhrOpen) {
-      XMLHttpRequest.prototype.open = this.originalXhrOpen;
+    return {
+      size: this.flagCache.size,
+      keys,
+      oldestEntry,
+      newestEntry
+    };
+  }
+  // Check if a flag exists in cache
+  hasCachedFlag(key) {
+    return this.flagCache.has(key);
+  }
+  // Get all cached flags (for debugging)
+  getAllCachedFlags() {
+    const result = {};
+    for (const [key, entry] of this.flagCache.entries()) {
+      result[key] = entry.value;
     }
-    if (this.clickHandler) {
-      document.removeEventListener("click", this.clickHandler, true);
+    return result;
+  }
+  // Preload specific flags
+  async preloadFlags(keys) {
+    const missing = keys.filter((key) => !this.hasCachedFlag(key));
+    if (missing.length > 0) {
+      await this.fetchFlags();
     }
   }
+  shutdown() {
+    this.closeRealtimeUpdates();
+    this.flagCache.clear();
+  }
 };
 
 // src/offline.ts
-var DB_NAME = "shellapps_experience";
-var STORE_NAME = "offline_queue";
+var DB_NAME = "ExperienceSDKOffline";
 var DB_VERSION = 1;
-function openDB() {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(STORE_NAME)) {
-        db.createObjectStore(STORE_NAME, { autoIncrement: true });
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-}
-async function enqueueOffline(data) {
-  const db = await openDB();
-  const tx = db.transaction(STORE_NAME, "readwrite");
-  tx.objectStore(STORE_NAME).add(data);
-  await new Promise((resolve, reject) => {
-    tx.oncomplete = () => resolve();
-    tx.onerror = () => reject(tx.error);
-  });
-  db.close();
-}
-async function drainOfflineQueue(sendFn) {
-  const db = await openDB();
-  const tx = db.transaction(STORE_NAME, "readwrite");
-  const store = tx.objectStore(STORE_NAME);
-  const cursorReq = store.openCursor();
-  await new Promise((resolve, reject) => {
-    cursorReq.onsuccess = async () => {
-      const cursor = cursorReq.result;
-      if (!cursor) {
-        resolve();
+var EVENTS_STORE = "events";
+var ERRORS_STORE = "errors";
+var MAX_OFFLINE_ITEMS = 1e3;
+var OfflineQueue = class {
+  constructor(transport, debug = false) {
+    this.db = null;
+    this.isInitialized = false;
+    this.unsubscribeFns = [];
+    this.isProcessing = false;
+    this.transport = transport;
+    this.debug = debug;
+    this.initialize();
+    this.setupOnlineListener();
+  }
+  async initialize() {
+    if (typeof indexedDB === "undefined") {
+      if (this.debug) {
+        console.warn("[ExperienceSDK] IndexedDB not available, offline queue disabled");
+      }
+      return;
+    }
+    try {
+      this.db = await this.openDatabase();
+      this.isInitialized = true;
+      if (this.debug) {
+        console.log("[ExperienceSDK] Offline queue initialized");
+      }
+      this.processStoredItems();
+    } catch (error) {
+      if (this.debug) {
+        console.error("[ExperienceSDK] Failed to initialize offline queue:", error);
+      }
+    }
+  }
+  openDatabase() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(EVENTS_STORE)) {
+          const eventsStore = db.createObjectStore(EVENTS_STORE, { keyPath: "id" });
+          eventsStore.createIndex("timestamp", "timestamp");
+          eventsStore.createIndex("type", "type");
+        }
+        if (!db.objectStoreNames.contains(ERRORS_STORE)) {
+          const errorsStore = db.createObjectStore(ERRORS_STORE, { keyPath: "id" });
+          errorsStore.createIndex("timestamp", "timestamp");
+          errorsStore.createIndex("type", "type");
+        }
+      };
+    });
+  }
+  setupOnlineListener() {
+    if (typeof window === "undefined") return;
+    const handleOnline = () => {
+      if (this.debug) {
+        console.log("[ExperienceSDK] Network online, processing offline queue");
+      }
+      this.processStoredItems();
+    };
+    window.addEventListener("online", handleOnline);
+    this.unsubscribeFns.push(
+      () => window.removeEventListener("online", handleOnline)
+    );
+  }
+  generateId() {
+    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  async storeEventBatch(batch) {
+    if (!this.isInitialized || !this.db) return;
+    const storedBatch = {
+      id: this.generateId(),
+      timestamp: Date.now(),
+      type: "events",
+      data: batch,
+      retryCount: 0
+    };
+    try {
+      await this.storeItem(EVENTS_STORE, storedBatch);
+      if (this.debug) {
+        console.log("[ExperienceSDK] Event batch stored offline:", storedBatch.id);
+      }
+      this.cleanupOldItems(EVENTS_STORE);
+    } catch (error) {
+      if (this.debug) {
+        console.error("[ExperienceSDK] Failed to store event batch offline:", error);
+      }
+    }
+  }
+  async storeErrorBatch(batch) {
+    if (!this.isInitialized || !this.db) return;
+    const storedBatch = {
+      id: this.generateId(),
+      timestamp: Date.now(),
+      type: "errors",
+      data: batch,
+      retryCount: 0
+    };
+    try {
+      await this.storeItem(ERRORS_STORE, storedBatch);
+      if (this.debug) {
+        console.log("[ExperienceSDK] Error batch stored offline:", storedBatch.id);
+      }
+      this.cleanupOldItems(ERRORS_STORE);
+    } catch (error) {
+      if (this.debug) {
+        console.error("[ExperienceSDK] Failed to store error batch offline:", error);
+      }
+    }
+  }
+  storeItem(storeName, item) {
+    return new Promise((resolve, reject) => {
+      if (!this.db) {
+        reject(new Error("Database not initialized"));
+        return;
+      }
+      const transaction = this.db.transaction([storeName], "readwrite");
+      const store = transaction.objectStore(storeName);
+      const request = store.put(item);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+  async cleanupOldItems(storeName) {
+    if (!this.db) return;
+    try {
+      const items = await this.getAllItems(storeName);
+      if (items.length > MAX_OFFLINE_ITEMS) {
+        const itemsToRemove = items.sort((a, b) => a.timestamp - b.timestamp).slice(0, items.length - MAX_OFFLINE_ITEMS);
+        await Promise.all(
+          itemsToRemove.map((item) => this.removeItem(storeName, item.id))
+        );
+        if (this.debug) {
+          console.log(`[ExperienceSDK] Cleaned up ${itemsToRemove.length} old offline items`);
+        }
+      }
+    } catch (error) {
+      if (this.debug) {
+        console.error("[ExperienceSDK] Failed to cleanup old items:", error);
+      }
+    }
+  }
+  getAllItems(storeName) {
+    return new Promise((resolve, reject) => {
+      if (!this.db) {
+        reject(new Error("Database not initialized"));
+        return;
+      }
+      const transaction = this.db.transaction([storeName], "readonly");
+      const store = transaction.objectStore(storeName);
+      const request = store.getAll();
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  removeItem(storeName, id) {
+    return new Promise((resolve, reject) => {
+      if (!this.db) {
+        reject(new Error("Database not initialized"));
         return;
       }
-      const item = cursor.value;
+      const transaction = this.db.transaction([storeName], "readwrite");
+      const store = transaction.objectStore(storeName);
+      const request = store.delete(id);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+  async processStoredItems() {
+    if (!this.isInitialized || !this.db || this.isProcessing) return;
+    if (typeof navigator !== "undefined" && navigator.onLine === false) {
+      if (this.debug) {
+        console.log("[ExperienceSDK] Still offline, skipping queue processing");
+      }
+      return;
+    }
+    this.isProcessing = true;
+    try {
+      await this.processStoreItems(EVENTS_STORE);
+      await this.processStoreItems(ERRORS_STORE);
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  async processStoreItems(storeName) {
+    try {
+      const items = await this.getAllItems(storeName);
+      if (items.length === 0) return;
+      if (this.debug) {
+        console.log(`[ExperienceSDK] Processing ${items.length} offline ${storeName}`);
+      }
+      items.sort((a, b) => a.timestamp - b.timestamp);
+      for (const item of items) {
+        try {
+          let success = false;
+          if (storeName === EVENTS_STORE && item.type === "events") {
+            const result = await this.transport.sendEventBatch(item.data);
+            success = result.success !== false;
+          } else if (storeName === ERRORS_STORE && item.type === "errors") {
+            const result = await this.transport.sendErrorBatch(item.data);
+            success = result.success !== false;
+          }
+          if (success) {
+            await this.removeItem(storeName, item.id);
+            if (this.debug) {
+              console.log(`[ExperienceSDK] Offline ${item.type} sent successfully:`, item.id);
+            }
+          } else {
+            throw new Error("Send failed");
+          }
+        } catch (error) {
+          if (this.debug) {
+            console.error(`[ExperienceSDK] Failed to send offline ${item.type}:`, error);
+          }
+          item.retryCount++;
+          if (item.retryCount >= 3) {
+            await this.removeItem(storeName, item.id);
+            if (this.debug) {
+              console.log(`[ExperienceSDK] Removing ${item.type} after ${item.retryCount} retries:`, item.id);
+            }
+          } else {
+            await this.storeItem(storeName, item);
+          }
+        }
+      }
+    } catch (error) {
+      if (this.debug) {
+        console.error(`[ExperienceSDK] Failed to process offline ${storeName}:`, error);
+      }
+    }
+  }
+  // Get queue status for debugging
+  async getQueueStatus() {
+    let eventCount = 0;
+    let errorCount = 0;
+    if (this.isInitialized && this.db) {
       try {
-        await sendFn(item.url, item.body);
-        cursor.delete();
-        cursor.continue();
-      } catch {
-        resolve();
+        const events = await this.getAllItems(EVENTS_STORE);
+        const errors = await this.getAllItems(ERRORS_STORE);
+        eventCount = events.length;
+        errorCount = errors.length;
+      } catch (error) {
       }
+    }
+    return {
+      events: eventCount,
+      errors: errorCount,
+      isOnline: typeof navigator !== "undefined" ? navigator.onLine : true,
+      isInitialized: this.isInitialized
     };
-    cursorReq.onerror = () => reject(cursorReq.error);
-  });
-  db.close();
-}
-
-// src/utils.ts
-function generateUUID() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  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);
-  });
-}
-function getPageContext() {
-  return {
-    path: location.pathname,
-    title: document.title,
-    referrer: document.referrer,
-    viewportWidth: window.innerWidth,
-    viewportHeight: window.innerHeight
-  };
-}
-function throttle(fn, ms) {
-  let last = 0;
-  return ((...args) => {
-    const now = Date.now();
-    if (now - last >= ms) {
-      last = now;
-      fn(...args);
+  }
+  // Clear all offline data
+  async clear() {
+    if (!this.isInitialized || !this.db) return;
+    try {
+      const transaction = this.db.transaction([EVENTS_STORE, ERRORS_STORE], "readwrite");
+      await Promise.all([
+        new Promise((resolve, reject) => {
+          const request = transaction.objectStore(EVENTS_STORE).clear();
+          request.onerror = () => reject(request.error);
+          request.onsuccess = () => resolve();
+        }),
+        new Promise((resolve, reject) => {
+          const request = transaction.objectStore(ERRORS_STORE).clear();
+          request.onerror = () => reject(request.error);
+          request.onsuccess = () => resolve();
+        })
+      ]);
+      if (this.debug) {
+        console.log("[ExperienceSDK] Offline queue cleared");
+      }
+    } catch (error) {
+      if (this.debug) {
+        console.error("[ExperienceSDK] Failed to clear offline queue:", error);
+      }
     }
-  });
-}
+  }
+  shutdown() {
+    this.unsubscribeFns.forEach((fn) => fn());
+    this.unsubscribeFns = [];
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.isInitialized = false;
+  }
+};
 
 // src/experience.ts
-var DEFAULT_CONFIG = {
-  endpoint: "",
-  enableTracking: true,
-  enableErrorCapture: true,
-  enableHeatmaps: false,
-  enableBreadcrumbs: true,
-  sampleRate: 1,
-  batchIntervalMs: 5e3,
-  maxBatchSize: 50,
-  debug: false
-};
-var Experience = class _Experience {
+var _Experience = class _Experience {
   constructor(config) {
-    this.profileId = "";
-    this.eventQueue = [];
-    this.errorQueue = [];
-    this.batchTimer = null;
-    this.flags = {};
-    this.flagsFetched = false;
-    this.teardownFns = [];
-    this.destroyed = false;
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.breadcrumbs = new BreadcrumbManager();
-    const stored = typeof sessionStorage !== "undefined" ? sessionStorage.getItem("exp_session_id") : null;
-    if (stored) {
-      this.sessionId = stored;
-    } else {
-      this.sessionId = generateUUID();
-      if (typeof sessionStorage !== "undefined") {
-        sessionStorage.setItem("exp_session_id", this.sessionId);
-      }
+    this.isShutdown = false;
+    this.isInSample = true;
+    this.config = this.resolveConfig(config);
+    this.isInSample = Math.random() < this.config.sampleRate;
+    if (this.config.debug) {
+      console.log("[ExperienceSDK] Initializing with config:", this.config);
+      console.log("[ExperienceSDK] In sample:", this.isInSample);
     }
+    this.sessionManager = new SessionManager();
+    this.transport = new Transport({
+      endpoint: this.config.endpoint,
+      apiKey: this.config.apiKey,
+      debug: this.config.debug
+    });
+    this.batcher = new EventBatcher(
+      this.transport,
+      this.config.batchIntervalMs,
+      this.config.maxBatchSize,
+      this.config.debug
+    );
+    this.breadcrumbManager = new BreadcrumbManager();
+    this.heatmapTracker = new HeatmapTracker(this.batcher, this.sessionManager.getSessionId());
+    this.errorCapture = new ErrorCapture(this.batcher, this.breadcrumbManager, this.sessionManager.getSessionId());
+    this.autoTracker = new AutoTracker(this.batcher, this.sessionManager.getSessionId());
+    this.dataTTracker = new DataTTracker(this.batcher, this.sessionManager.getSessionId());
+    this.flagClient = new FeatureFlagClient(this.transport, this.config.appId, this.config.debug);
+    this.offlineQueue = new OfflineQueue(this.transport, this.config.debug);
+    this.setupFailureHandling();
+    this.enableFeatures();
   }
-  static init(config) {
-    const instance = new _Experience(config);
-    instance.setup();
-    return instance;
+  resolveConfig(config) {
+    return {
+      appId: config.appId,
+      apiKey: config.apiKey,
+      endpoint: config.endpoint || "https://experience.shellapps.com",
+      enableTracking: config.enableTracking ?? true,
+      enableErrorCapture: config.enableErrorCapture ?? true,
+      enableHeatmaps: config.enableHeatmaps ?? false,
+      enableBreadcrumbs: config.enableBreadcrumbs ?? true,
+      sampleRate: Math.max(0, Math.min(1, config.sampleRate ?? 1)),
+      batchIntervalMs: config.batchIntervalMs ?? 2e3,
+      maxBatchSize: config.maxBatchSize ?? 50,
+      debug: config.debug ?? false
+    };
   }
-  log(...args) {
-    if (this.config.debug) {
-      console.log("[Experience]", ...args);
-    }
+  setupFailureHandling() {
+    const originalSendEventBatch = this.transport.sendEventBatch.bind(this.transport);
+    const originalSendErrorBatch = this.transport.sendErrorBatch.bind(this.transport);
+    this.transport.sendEventBatch = async (batch) => {
+      try {
+        return await originalSendEventBatch(batch);
+      } catch (error) {
+        await this.offlineQueue.storeEventBatch(batch);
+        throw error;
+      }
+    };
+    this.transport.sendErrorBatch = async (batch) => {
+      try {
+        return await originalSendErrorBatch(batch);
+      } catch (error) {
+        await this.offlineQueue.storeErrorBatch(batch);
+        throw error;
+      }
+    };
   }
-  setup() {
-    if (Math.random() > this.config.sampleRate) {
-      this.log("Sampled out");
+  enableFeatures() {
+    if (!this.isInSample) {
+      if (this.config.debug) {
+        console.log("[ExperienceSDK] Not in sample, features disabled");
+      }
       return;
     }
     if (this.config.enableBreadcrumbs) {
-      this.breadcrumbs.install();
+      this.breadcrumbManager.enable();
     }
     if (this.config.enableErrorCapture) {
-      this.setupErrorCapture();
+      this.errorCapture.enable();
     }
     if (this.config.enableTracking) {
-      this.setupAutoPageViews();
+      this.autoTracker.enable();
+      this.dataTTracker.enable();
     }
     if (this.config.enableHeatmaps) {
-      this.setupHeatmaps();
-    }
-    this.batchTimer = setInterval(() => this.flush(), this.config.batchIntervalMs);
-    const beforeUnload = () => this.flushSync();
-    window.addEventListener("beforeunload", beforeUnload);
-    this.teardownFns.push(() => window.removeEventListener("beforeunload", beforeUnload));
-    const onlineHandler = () => {
-      this.log("Back online, draining queue");
-      drainOfflineQueue((url, body) => this.sendRequest(url, body)).catch(() => {
-      });
-    };
-    window.addEventListener("online", onlineHandler);
-    this.teardownFns.push(() => window.removeEventListener("online", onlineHandler));
-    this.fetchFlags().catch(() => {
+      this.heatmapTracker.enable();
+    }
+    this.flagClient.initialize().catch((error) => {
+      if (this.config.debug) {
+        console.error("[ExperienceSDK] Failed to initialize flags:", error);
+      }
     });
-    this.log("Initialized", this.config.appId);
   }
-  // --- Public API ---
-  track(eventName, metadata) {
-    if (this.destroyed) return;
-    this.enqueueEvent("custom", eventName, metadata);
+  // Public API
+  track(eventType, metadata) {
+    if (!this.isInSample || this.isShutdown || !this.config.enableTracking) return;
+    const pageContext = this.getCurrentPageContext();
+    const trackEvent = {
+      eventType,
+      sessionId: this.sessionManager.getSessionId(),
+      timestamp: Date.now(),
+      metadata,
+      pageContext
+    };
+    this.batcher.addTrackEvent(trackEvent);
+    if (this.config.debug) {
+      console.log("[ExperienceSDK] Event tracked:", trackEvent);
+    }
   }
   trackPageView() {
-    if (this.destroyed) return;
-    this.enqueueEvent("page_view", "page_view");
-    this.breadcrumbs.add({ type: "navigation", category: "page_view", message: location.href });
+    this.autoTracker.trackCurrentPage();
   }
-  captureError(error, extra) {
-    if (this.destroyed) return;
-    this.enqueueError(error.message, error.stack || "", "error", extra);
+  captureError(error, options) {
+    if (!this.isInSample || this.isShutdown || !this.config.enableErrorCapture) return;
+    this.errorCapture.captureException(error, options);
   }
-  captureMessage(msg, severity = "info") {
-    if (this.destroyed) return;
-    this.enqueueError(msg, "", severity);
+  captureMessage(message, severity) {
+    if (!this.isInSample || this.isShutdown || !this.config.enableErrorCapture) return;
+    const sev = severity ? ErrorCapture.getSeverityFromString(severity) : 0 /* INFO */;
+    this.errorCapture.captureMessage(message, sev);
   }
-  getFlag(name, defaultValue) {
-    if (!this.flagsFetched || !(name in this.flags)) return defaultValue;
-    return this.flags[name];
+  getFlag(key, defaultValue) {
+    if (this.isShutdown) return defaultValue;
+    return this.flagClient.getFlag(key, defaultValue);
   }
   identify(profileId) {
-    this.profileId = profileId;
-    this.log("Identified", profileId);
+    if (this.isShutdown) return;
+    this.flagClient.setProfileId(profileId);
+    if (this.config.debug) {
+      console.log("[ExperienceSDK] Profile identified:", profileId);
+    }
   }
   async shutdown() {
-    if (this.destroyed) return;
-    this.destroyed = true;
-    if (this.batchTimer) {
-      clearInterval(this.batchTimer);
-      this.batchTimer = null;
-    }
-    await this.flush();
-    this.breadcrumbs.teardown();
-    this.teardownFns.forEach((fn) => fn());
-    this.teardownFns = [];
-    this.log("Shutdown complete");
-  }
-  // --- Internal ---
-  enqueueEvent(eventType, eventName, metadata) {
-    const event = {
-      eventId: generateUUID(),
-      appId: this.config.appId,
-      profileId: this.profileId,
-      sessionId: this.sessionId,
-      timestampMs: Date.now(),
-      eventType,
-      pageUrl: location.href,
-      elementTid: metadata?.elementTid || "",
-      metadata: { eventName, ...metadata },
-      pageContext: getPageContext(),
-      elementContext: null
-    };
-    this.eventQueue.push(event);
-    if (this.eventQueue.length >= this.config.maxBatchSize) {
-      this.flush().catch(() => {
-      });
+    if (this.isShutdown) return;
+    this.isShutdown = true;
+    if (this.config.debug) {
+      console.log("[ExperienceSDK] Shutting down...");
+    }
+    this.breadcrumbManager.disable();
+    this.errorCapture.disable();
+    this.heatmapTracker.disable();
+    this.autoTracker.disable();
+    this.dataTTracker.disable();
+    await Promise.all([
+      this.batcher.shutdown(),
+      this.flagClient.shutdown(),
+      this.offlineQueue.shutdown()
+    ]);
+    if (this.config.debug) {
+      console.log("[ExperienceSDK] Shutdown complete");
     }
   }
-  enqueueError(message, stack, severity, extra) {
-    const report = {
-      eventId: generateUUID(),
-      appId: this.config.appId,
-      profileId: this.profileId,
-      sessionId: this.sessionId,
-      timestampMs: Date.now(),
-      message,
-      stack,
-      severity,
-      extra: extra || {},
-      pageContext: getPageContext(),
-      breadcrumbs: this.breadcrumbs.getAll()
+  // Utility methods
+  getCurrentPageContext() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return {
+        url: "unknown",
+        title: "unknown",
+        referrer: "",
+        viewport: { width: 1920, height: 1080 }
+      };
+    }
+    return {
+      url: window.location.href,
+      title: document.title || "",
+      referrer: document.referrer || "",
+      viewport: {
+        width: window.innerWidth || 1920,
+        height: window.innerHeight || 1080
+      }
+    };
+  }
+  // Debug methods
+  getSessionInfo() {
+    return {
+      sessionId: this.sessionManager.getSessionId(),
+      duration: this.sessionManager.getSessionDuration(),
+      isInSample: this.isInSample
+    };
+  }
+  async getQueueStatus() {
+    const offlineStatus = await this.offlineQueue.getQueueStatus();
+    return {
+      pendingEvents: this.batcher.getPendingEventCount(),
+      pendingErrors: this.batcher.getPendingErrorCount(),
+      offlineQueue: offlineStatus
     };
-    this.errorQueue.push(report);
   }
+  getBreadcrumbs() {
+    return this.breadcrumbManager.getBreadcrumbs();
+  }
+  getFlagCacheInfo() {
+    return this.flagClient.getCacheInfo();
+  }
+  // Manual flush for testing
   async flush() {
-    if (this.eventQueue.length > 0) {
-      const events = this.eventQueue.splice(0);
-      const url = `${this.config.endpoint}/api/v1/ingest/events`;
-      const body = JSON.stringify({ events });
-      await this.sendOrQueue(url, body);
-    }
-    if (this.errorQueue.length > 0) {
-      const errors = this.errorQueue.splice(0);
-      const url = `${this.config.endpoint}/api/v1/ingest/errors`;
-      const body = JSON.stringify({ errors });
-      await this.sendOrQueue(url, body);
-    }
-  }
-  flushSync() {
-    if (typeof navigator.sendBeacon !== "function") return;
-    if (this.eventQueue.length > 0) {
-      const url = `${this.config.endpoint}/api/v1/ingest/events`;
-      const blob = new Blob([JSON.stringify({ events: this.eventQueue.splice(0) })], { type: "application/json" });
-      navigator.sendBeacon(url, blob);
-    }
-    if (this.errorQueue.length > 0) {
-      const url = `${this.config.endpoint}/api/v1/ingest/errors`;
-      const blob = new Blob([JSON.stringify({ errors: this.errorQueue.splice(0) })], { type: "application/json" });
-      navigator.sendBeacon(url, blob);
-    }
-  }
-  async sendOrQueue(url, body) {
-    if (typeof navigator !== "undefined" && !navigator.onLine) {
-      await enqueueOffline({ url, body });
-      return;
-    }
-    try {
-      await this.sendRequest(url, body);
-    } catch {
-      await enqueueOffline({ url, body }).catch(() => {
-      });
-    }
+    if (this.isShutdown) return;
+    await this.batcher.forceFlush();
+    await this.offlineQueue.processStoredItems();
   }
-  async sendRequest(url, body) {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.config.apiKey}`
-      },
-      body
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
+  // Static factory method (singleton pattern)
+  static init(config) {
+    if (_Experience.instance) {
+      if (config.debug) {
+        console.warn("[ExperienceSDK] Already initialized, returning existing instance");
+      }
+      return _Experience.instance;
     }
+    _Experience.instance = new _Experience(config);
+    return _Experience.instance;
   }
-  async fetchFlags() {
-    try {
-      const url = `${this.config.endpoint}/api/v1/flags/${this.config.appId}`;
-      const response = await fetch(url, {
-        headers: { "Authorization": `Bearer ${this.config.apiKey}` }
-      });
-      if (response.ok) {
-        this.flags = await response.json();
-        this.flagsFetched = true;
-        this.log("Flags loaded", this.flags);
-      }
-    } catch {
-      this.log("Failed to fetch flags");
-    }
-  }
-  // --- Auto features ---
-  setupErrorCapture() {
-    const onError = (event) => {
-      this.enqueueError(
-        event.message,
-        event.error?.stack || "",
-        "error",
-        { filename: event.filename, lineno: event.lineno, colno: event.colno }
-      );
-    };
-    window.addEventListener("error", onError);
-    this.teardownFns.push(() => window.removeEventListener("error", onError));
-    const onUnhandledRejection = (event) => {
-      const msg = event.reason instanceof Error ? event.reason.message : String(event.reason);
-      const stack = event.reason instanceof Error ? event.reason.stack || "" : "";
-      this.enqueueError(msg, stack, "error", { type: "unhandledrejection" });
-    };
-    window.addEventListener("unhandledrejection", onUnhandledRejection);
-    this.teardownFns.push(() => window.removeEventListener("unhandledrejection", onUnhandledRejection));
-  }
-  setupAutoPageViews() {
-    const originalPushState = history.pushState.bind(history);
-    const originalReplaceState = history.replaceState.bind(history);
-    history.pushState = (...args) => {
-      originalPushState(...args);
-      this.trackPageView();
+  static getInstance() {
+    return _Experience.instance;
+  }
+  // Advanced tracking methods
+  trackElement(element, eventType) {
+    if (!this.isInSample || this.isShutdown || !this.config.enableTracking) return;
+    const elementContext = {
+      selector: this.getElementSelector(element),
+      tag: element.tagName.toLowerCase(),
+      dataT: element.getAttribute("data-t") || void 0
     };
-    history.replaceState = (...args) => {
-      originalReplaceState(...args);
-      this.trackPageView();
+    const trackEvent = {
+      eventType,
+      sessionId: this.sessionManager.getSessionId(),
+      timestamp: Date.now(),
+      pageContext: this.getCurrentPageContext(),
+      elementContext
     };
-    this.teardownFns.push(() => {
-      history.pushState = originalPushState;
-      history.replaceState = originalReplaceState;
-    });
-    const onPopState = () => this.trackPageView();
-    window.addEventListener("popstate", onPopState);
-    this.teardownFns.push(() => window.removeEventListener("popstate", onPopState));
-    this.trackPageView();
+    this.batcher.addTrackEvent(trackEvent);
   }
-  setupHeatmaps() {
-    const handleMove = throttle((e) => {
-      this.enqueueEvent("heatmap_move", "mousemove", {
-        x: e.clientX,
-        y: e.clientY,
-        viewportWidth: window.innerWidth,
-        viewportHeight: window.innerHeight
-      });
-    }, 100);
-    const handleClick = (e) => {
-      const target = e.target;
-      this.enqueueEvent("heatmap_click", "click", {
-        x: e.clientX,
-        y: e.clientY,
-        viewportWidth: window.innerWidth,
-        viewportHeight: window.innerHeight,
-        tag: target?.tagName?.toLowerCase() || "",
-        text: (target?.textContent || "").slice(0, 100)
-      });
-    };
-    document.addEventListener("mousemove", handleMove);
-    document.addEventListener("click", handleClick);
-    this.teardownFns.push(() => {
-      document.removeEventListener("mousemove", handleMove);
-      document.removeEventListener("click", handleClick);
-    });
+  getElementSelector(element) {
+    try {
+      const tag = element.tagName.toLowerCase();
+      const id = element.id ? `#${element.id}` : "";
+      const className = element.className && typeof element.className === "string" ? `.${element.className.split(" ").filter((c) => c.trim()).join(".")}` : "";
+      return `${tag}${id}${className}`.slice(0, 100);
+    } catch {
+      return element.tagName?.toLowerCase() || "unknown";
+    }
   }
 };
+_Experience.instance = null;
+var Experience = _Experience;
 export {
-  Experience
+  AutoTracker,
+  BreadcrumbManager,
+  DataTTracker,
+  ErrorCapture,
+  EventBatcher,
+  Experience,
+  FeatureFlagClient,
+  HeatmapTracker,
+  OfflineQueue,
+  schemas_exports as ProtoSchemas,
+  ProtobufEncoder,
+  SessionManager,
+  Severity,
+  Transport
 };
 //# sourceMappingURL=index.mjs.map