@outlit/browser 0.1.0 → 0.2.1

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { i as init, t as track, a as identify, g as getInstance, T as Tracker, e as enableTracking, b as isTrackingEnabled } from './tracker-CocH64L9.mjs';
-export { c as TrackerOptions } from './tracker-CocH64L9.mjs';
+import { i as init, t as track, a as identify, g as getInstance, O as Outlit, e as enableTracking, b as isTrackingEnabled } from './tracker-DFcTv3EM.mjs';
+export { c as OutlitOptions } from './tracker-DFcTv3EM.mjs';
 export { BrowserIdentifyOptions, BrowserTrackOptions, TrackerConfig, UtmParams } from '@outlit/core';
 
 declare const _default: {
@@ -7,9 +7,9 @@ declare const _default: {
     track: typeof track;
     identify: typeof identify;
     getInstance: typeof getInstance;
-    Tracker: typeof Tracker;
+    Outlit: typeof Outlit;
     enableTracking: typeof enableTracking;
     isTrackingEnabled: typeof isTrackingEnabled;
 };
 
-export { Tracker, _default as default, enableTracking, getInstance, identify, init, isTrackingEnabled, track };
+export { Outlit, _default as default, enableTracking, getInstance, identify, init, isTrackingEnabled, track };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { i as init, t as track, a as identify, g as getInstance, T as Tracker, e as enableTracking, b as isTrackingEnabled } from './tracker-CocH64L9.js';
-export { c as TrackerOptions } from './tracker-CocH64L9.js';
+import { i as init, t as track, a as identify, g as getInstance, O as Outlit, e as enableTracking, b as isTrackingEnabled } from './tracker-DFcTv3EM.js';
+export { c as OutlitOptions } from './tracker-DFcTv3EM.js';
 export { BrowserIdentifyOptions, BrowserTrackOptions, TrackerConfig, UtmParams } from '@outlit/core';
 
 declare const _default: {
@@ -7,9 +7,9 @@ declare const _default: {
     track: typeof track;
     identify: typeof identify;
     getInstance: typeof getInstance;
-    Tracker: typeof Tracker;
+    Outlit: typeof Outlit;
     enableTracking: typeof enableTracking;
     isTrackingEnabled: typeof isTrackingEnabled;
 };
 
-export { Tracker, _default as default, enableTracking, getInstance, identify, init, isTrackingEnabled, track };
+export { Outlit, _default as default, enableTracking, getInstance, identify, init, isTrackingEnabled, track };

package/dist/index.js

@@ -20,7 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  Tracker: () => Tracker,
+  Outlit: () => Outlit,
   default: () => src_default,
   enableTracking: () => enableTracking,
   getInstance: () => getInstance,
@@ -32,7 +32,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/tracker.ts
-var import_core2 = require("@outlit/core");
+var import_core3 = require("@outlit/core");
 
 // src/autocapture.ts
 var import_core = require("@outlit/core");
@@ -52,19 +52,22 @@ function capturePageview() {
   lastUrl = url;
   pageviewCallback(url, referrer, title);
 }
+function capturePageviewDelayed() {
+  setTimeout(capturePageview, 10);
+}
 function setupSpaListeners() {
   window.addEventListener("popstate", () => {
-    capturePageview();
+    capturePageviewDelayed();
   });
   const originalPushState = history.pushState;
   const originalReplaceState = history.replaceState;
   history.pushState = function(...args) {
     originalPushState.apply(this, args);
-    capturePageview();
+    capturePageviewDelayed();
   };
   history.replaceState = function(...args) {
     originalReplaceState.apply(this, args);
-    capturePageview();
+    capturePageviewDelayed();
   };
 }
 var formCallback = null;
@@ -115,6 +118,431 @@ function stopAutocapture() {
   document.removeEventListener("submit", handleFormSubmit, true);
 }
 
+// src/embed-integrations.ts
+var callbacks = null;
+var isListening = false;
+var calSetupAttempts = 0;
+var calCallbackRegistered = false;
+var lastBookingUid = null;
+var CAL_MAX_RETRY_ATTEMPTS = 10;
+var CAL_INITIAL_DELAY_MS = 200;
+var CAL_MAX_DELAY_MS = 2e3;
+function parseCalComBooking(data) {
+  const event = {
+    provider: "cal.com"
+  };
+  if (data.title) {
+    event.eventType = data.title;
+    const nameMatch = data.title.match(/between .+ and (.+)$/i);
+    if (nameMatch?.[1]) {
+      event.inviteeName = nameMatch[1].trim();
+    }
+  }
+  if (data.startTime) event.startTime = data.startTime;
+  if (data.endTime) event.endTime = data.endTime;
+  if (data.startTime && data.endTime) {
+    const start = new Date(data.startTime);
+    const end = new Date(data.endTime);
+    event.duration = Math.round((end.getTime() - start.getTime()) / 6e4);
+  }
+  if (data.isRecurring !== void 0) {
+    event.isRecurring = data.isRecurring;
+  }
+  return event;
+}
+function setupCalComListener() {
+  if (typeof window === "undefined") return;
+  if (calCallbackRegistered) return;
+  calSetupAttempts++;
+  if ("Cal" in window) {
+    const Cal = window.Cal;
+    if (typeof Cal === "function") {
+      try {
+        Cal("on", {
+          action: "bookingSuccessfulV2",
+          callback: handleCalComBooking
+        });
+        calCallbackRegistered = true;
+        return;
+      } catch (_e) {
+      }
+    }
+  }
+  if (calSetupAttempts < CAL_MAX_RETRY_ATTEMPTS) {
+    const delay = Math.min(CAL_INITIAL_DELAY_MS * calSetupAttempts, CAL_MAX_DELAY_MS);
+    setTimeout(setupCalComListener, delay);
+  }
+}
+function handleCalComBooking(e) {
+  if (!callbacks) return;
+  const data = e.detail?.data;
+  if (!data) return;
+  if (data.uid && data.uid === lastBookingUid) return;
+  lastBookingUid = data.uid || null;
+  const bookingEvent = parseCalComBooking(data);
+  callbacks.onCalendarBooked(bookingEvent);
+}
+function handlePostMessage(event) {
+  if (!callbacks) return;
+  if (isCalendlyEvent(event)) {
+    if (event.data.event === "calendly.event_scheduled") {
+      const bookingEvent = parseCalendlyBooking(event.data.payload);
+      callbacks.onCalendarBooked(bookingEvent);
+    }
+    return;
+  }
+  if (isCalComRawMessage(event)) {
+    const bookingData = extractCalComBookingFromMessage(event.data);
+    if (bookingData) {
+      if (bookingData.uid && bookingData.uid === lastBookingUid) return;
+      lastBookingUid = bookingData.uid || null;
+      const bookingEvent = parseCalComBooking(bookingData);
+      callbacks.onCalendarBooked(bookingEvent);
+    }
+  }
+}
+function isCalComRawMessage(event) {
+  if (!event.origin.includes("cal.com")) return false;
+  const data = event.data;
+  if (!data || typeof data !== "object") return false;
+  const messageType = data.type || data.action;
+  return messageType === "bookingSuccessfulV2" || messageType === "bookingSuccessful" || messageType === "booking_successful";
+}
+function extractCalComBookingFromMessage(data) {
+  if (!data || typeof data !== "object") return null;
+  const messageData = data;
+  if (messageData.data && typeof messageData.data === "object") {
+    return messageData.data;
+  }
+  if (messageData.booking && typeof messageData.booking === "object") {
+    return messageData.booking;
+  }
+  return null;
+}
+function isCalendlyEvent(e) {
+  return e.origin === "https://calendly.com" && e.data && typeof e.data.event === "string" && e.data.event.startsWith("calendly.");
+}
+function parseCalendlyBooking(_payload) {
+  return {
+    provider: "calendly"
+  };
+}
+function initCalendarTracking(cbs) {
+  if (isListening) return;
+  callbacks = cbs;
+  isListening = true;
+  calSetupAttempts = 0;
+  window.addEventListener("message", handlePostMessage);
+  setupCalComListener();
+}
+function stopCalendarTracking() {
+  if (!isListening) return;
+  window.removeEventListener("message", handlePostMessage);
+  callbacks = null;
+  isListening = false;
+  calCallbackRegistered = false;
+  calSetupAttempts = 0;
+  lastBookingUid = null;
+}
+
+// src/session-tracker.ts
+var import_core2 = require("@outlit/core");
+var DEFAULT_IDLE_TIMEOUT = 3e4;
+var SESSION_TIMEOUT = 30 * 60 * 1e3;
+var TIME_UPDATE_INTERVAL = 1e3;
+var MIN_SPURIOUS_THRESHOLD = 50;
+var SESSION_ID_KEY = "outlit_session_id";
+var SESSION_LAST_ACTIVITY_KEY = "outlit_session_last_activity";
+var SessionTracker = class {
+  state;
+  options;
+  idleTimeout;
+  timeUpdateInterval = null;
+  boundHandleActivity;
+  boundHandleVisibilityChange;
+  constructor(options) {
+    this.options = options;
+    this.idleTimeout = options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
+    this.state = this.createInitialState();
+    this.boundHandleActivity = this.handleActivity.bind(this);
+    this.boundHandleVisibilityChange = this.handleVisibilityChange.bind(this);
+    this.setupEventListeners();
+    this.startTimeUpdateInterval();
+  }
+  /**
+   * Get the current session ID.
+   */
+  getSessionId() {
+    return this.state.sessionId;
+  }
+  // ============================================
+  // PUBLIC METHODS
+  // ============================================
+  /**
+   * Emit an engagement event for the current page session.
+   * Called by Tracker on exit events and SPA navigation.
+   *
+   * This method:
+   * 1. Finalizes any pending active time
+   * 2. Creates and emits the engagement event (if meaningful)
+   * 3. Resets state for the next session
+   */
+  emitEngagement() {
+    if (this.state.hasEmittedEngagement) {
+      return;
+    }
+    this.state.hasEmittedEngagement = true;
+    this.updateActiveTime();
+    const totalTimeMs = Date.now() - this.state.pageEntryTime;
+    const isSpuriousEvent = this.state.activeTimeMs < MIN_SPURIOUS_THRESHOLD && totalTimeMs < MIN_SPURIOUS_THRESHOLD;
+    if (!isSpuriousEvent) {
+      const event = (0, import_core2.buildEngagementEvent)({
+        url: this.state.currentUrl,
+        referrer: document.referrer,
+        activeTimeMs: this.state.activeTimeMs,
+        totalTimeMs,
+        sessionId: this.state.sessionId
+      });
+      this.options.onEngagement(event);
+    }
+    this.resetState();
+  }
+  /**
+   * Handle SPA navigation.
+   * Called by Tracker when a new pageview is detected.
+   *
+   * This method:
+   * 1. Emits engagement for the OLD page (using stored state)
+   * 2. Updates state for the NEW page
+   */
+  onNavigation(newUrl) {
+    this.emitEngagement();
+    this.state.currentUrl = newUrl;
+    this.state.currentPath = this.extractPath(newUrl);
+    this.state.pageEntryTime = Date.now();
+    this.state.activeTimeMs = 0;
+    this.state.lastActiveTime = Date.now();
+    this.state.isUserActive = true;
+    this.state.hasEmittedEngagement = false;
+    this.resetIdleTimer();
+  }
+  /**
+   * Stop session tracking and clean up.
+   */
+  stop() {
+    this.removeEventListeners();
+    if (this.timeUpdateInterval) {
+      clearInterval(this.timeUpdateInterval);
+      this.timeUpdateInterval = null;
+    }
+    if (this.state.idleTimeoutId) {
+      clearTimeout(this.state.idleTimeoutId);
+      this.state.idleTimeoutId = null;
+    }
+  }
+  // ============================================
+  // PRIVATE METHODS
+  // ============================================
+  createInitialState() {
+    const now = Date.now();
+    return {
+      currentUrl: typeof window !== "undefined" ? window.location.href : "",
+      currentPath: typeof window !== "undefined" ? window.location.pathname : "/",
+      pageEntryTime: now,
+      lastActiveTime: now,
+      activeTimeMs: 0,
+      isPageVisible: typeof document !== "undefined" ? document.visibilityState === "visible" : true,
+      isUserActive: true,
+      // Assume active on page load
+      idleTimeoutId: null,
+      sessionId: this.getOrCreateSessionId(),
+      hasEmittedEngagement: false
+    };
+  }
+  resetState() {
+    const now = Date.now();
+    this.state.pageEntryTime = now;
+    this.state.lastActiveTime = now;
+    this.state.activeTimeMs = 0;
+    this.state.isUserActive = true;
+    this.resetIdleTimer();
+  }
+  /**
+   * Get existing session ID from storage or create a new one.
+   * Session ID is reset if:
+   * - No existing session ID in storage
+   * - Last activity was more than 30 minutes ago
+   */
+  getOrCreateSessionId() {
+    if (typeof sessionStorage === "undefined") {
+      return this.generateSessionId();
+    }
+    try {
+      const existingSessionId = sessionStorage.getItem(SESSION_ID_KEY);
+      const lastActivityStr = sessionStorage.getItem(SESSION_LAST_ACTIVITY_KEY);
+      const lastActivity = lastActivityStr ? Number.parseInt(lastActivityStr, 10) : 0;
+      const now = Date.now();
+      if (existingSessionId && lastActivity && now - lastActivity < SESSION_TIMEOUT) {
+        this.updateSessionActivity();
+        return existingSessionId;
+      }
+      const newSessionId = this.generateSessionId();
+      sessionStorage.setItem(SESSION_ID_KEY, newSessionId);
+      sessionStorage.setItem(SESSION_LAST_ACTIVITY_KEY, now.toString());
+      return newSessionId;
+    } catch {
+      return this.generateSessionId();
+    }
+  }
+  /**
+   * Generate a new session ID (UUID v4).
+   */
+  generateSessionId() {
+    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);
+    });
+  }
+  /**
+   * Update the session's last activity timestamp.
+   */
+  updateSessionActivity() {
+    if (typeof sessionStorage === "undefined") return;
+    try {
+      sessionStorage.setItem(SESSION_LAST_ACTIVITY_KEY, Date.now().toString());
+    } catch {
+    }
+  }
+  /**
+   * Check if the current session has expired and create a new one if needed.
+   * Called when user returns to the page after being away.
+   */
+  checkSessionExpiry() {
+    if (typeof sessionStorage === "undefined") return;
+    try {
+      const lastActivityStr = sessionStorage.getItem(SESSION_LAST_ACTIVITY_KEY);
+      const lastActivity = lastActivityStr ? Number.parseInt(lastActivityStr, 10) : 0;
+      const now = Date.now();
+      if (now - lastActivity >= SESSION_TIMEOUT) {
+        const newSessionId = this.generateSessionId();
+        sessionStorage.setItem(SESSION_ID_KEY, newSessionId);
+        this.state.sessionId = newSessionId;
+      }
+      sessionStorage.setItem(SESSION_LAST_ACTIVITY_KEY, now.toString());
+    } catch {
+    }
+  }
+  setupEventListeners() {
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    const activityEvents = ["mousemove", "keydown", "click", "scroll", "touchstart"];
+    for (const event of activityEvents) {
+      document.addEventListener(event, this.boundHandleActivity, { passive: true });
+    }
+    document.addEventListener("visibilitychange", this.boundHandleVisibilityChange);
+    this.resetIdleTimer();
+  }
+  removeEventListeners() {
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    const activityEvents = ["mousemove", "keydown", "click", "scroll", "touchstart"];
+    for (const event of activityEvents) {
+      document.removeEventListener(event, this.boundHandleActivity);
+    }
+    document.removeEventListener("visibilitychange", this.boundHandleVisibilityChange);
+  }
+  /**
+   * Handle user activity events.
+   * Marks user as active and resets idle timer.
+   */
+  handleActivity() {
+    if (!this.state.isUserActive) {
+      this.checkSessionExpiry();
+      this.state.lastActiveTime = Date.now();
+    }
+    this.state.isUserActive = true;
+    this.resetIdleTimer();
+    this.updateSessionActivity();
+  }
+  /**
+   * Handle visibility change events.
+   * Pauses time accumulation when tab is hidden.
+   */
+  handleVisibilityChange() {
+    const wasVisible = this.state.isPageVisible;
+    const isNowVisible = document.visibilityState === "visible";
+    if (wasVisible && !isNowVisible) {
+      this.updateActiveTime();
+    }
+    this.state.isPageVisible = isNowVisible;
+    if (!wasVisible && isNowVisible) {
+      this.checkSessionExpiry();
+      this.state.lastActiveTime = Date.now();
+      this.state.hasEmittedEngagement = false;
+    }
+  }
+  /**
+   * Reset the idle timer.
+   * Called on activity and initialization.
+   */
+  resetIdleTimer() {
+    if (this.state.idleTimeoutId) {
+      clearTimeout(this.state.idleTimeoutId);
+    }
+    this.state.idleTimeoutId = setTimeout(() => {
+      this.updateActiveTime();
+      this.state.isUserActive = false;
+    }, this.idleTimeout);
+  }
+  /**
+   * Start the interval for updating active time.
+   */
+  startTimeUpdateInterval() {
+    if (this.timeUpdateInterval) return;
+    this.timeUpdateInterval = setInterval(() => {
+      this.updateActiveTime();
+    }, TIME_UPDATE_INTERVAL);
+  }
+  /**
+   * Update accumulated active time.
+   * Only accumulates when page is visible AND user is active.
+   */
+  updateActiveTime() {
+    if (this.state.isPageVisible && this.state.isUserActive) {
+      const now = Date.now();
+      this.state.activeTimeMs += now - this.state.lastActiveTime;
+      this.state.lastActiveTime = now;
+    }
+  }
+  /**
+   * Extract path from URL.
+   */
+  extractPath(url) {
+    try {
+      return new URL(url).pathname;
+    } catch {
+      return "/";
+    }
+  }
+};
+var sessionTrackerInstance = null;
+function initSessionTracking(options) {
+  if (sessionTrackerInstance) {
+    console.warn("[Outlit] Session tracking already initialized");
+    return sessionTrackerInstance;
+  }
+  sessionTrackerInstance = new SessionTracker(options);
+  return sessionTrackerInstance;
+}
+function stopSessionTracking() {
+  if (sessionTrackerInstance) {
+    sessionTrackerInstance.stop();
+    sessionTrackerInstance = null;
+  }
+}
+
 // src/storage.ts
 var VISITOR_ID_KEY = "outlit_visitor_id";
 function generateVisitorId() {
@@ -196,7 +624,7 @@ function setCookie(name, value, days) {
 }
 
 // src/tracker.ts
-var Tracker = class {
+var Outlit = class {
   publicKey;
   apiHost;
   visitorId = null;
@@ -206,15 +634,29 @@ var Tracker = class {
   isInitialized = false;
   isTrackingEnabled = false;
   options;
+  hasHandledExit = false;
+  sessionTracker = null;
   constructor(options) {
     this.publicKey = options.publicKey;
-    this.apiHost = options.apiHost ?? import_core2.DEFAULT_API_HOST;
+    this.apiHost = options.apiHost ?? import_core3.DEFAULT_API_HOST;
     this.flushInterval = options.flushInterval ?? 5e3;
     this.options = options;
     if (typeof window !== "undefined") {
-      window.addEventListener("beforeunload", () => {
+      const handleExit = () => {
+        if (this.hasHandledExit) return;
+        this.hasHandledExit = true;
+        this.sessionTracker?.emitEngagement();
         this.flush();
+      };
+      document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden") {
+          handleExit();
+        } else {
+          this.hasHandledExit = false;
+        }
       });
+      window.addEventListener("pagehide", handleExit);
+      window.addEventListener("beforeunload", handleExit);
     }
     this.isInitialized = true;
     if (options.autoTrack !== false) {
@@ -239,12 +681,18 @@ var Tracker = class {
     }
     this.visitorId = getOrCreateVisitorId();
     this.startFlushTimer();
+    if (this.options.trackEngagement !== false) {
+      this.initSessionTracking();
+    }
     if (this.options.trackPageviews !== false) {
       this.initPageviewTracking();
     }
     if (this.options.trackForms !== false) {
       this.initFormTracking(this.options.formFieldDenylist);
     }
+    if (this.options.trackCalendarEmbeds !== false) {
+      this.initCalendarTracking();
+    }
     this.isTrackingEnabled = true;
   }
   /**
@@ -261,7 +709,7 @@ var Tracker = class {
       console.warn("[Outlit] Tracking not enabled. Call enableTracking() first.");
       return;
     }
-    const event = (0, import_core2.buildCustomEvent)({
+    const event = (0, import_core3.buildCustomEvent)({
       url: window.location.href,
       referrer: document.referrer,
       eventName,
@@ -278,7 +726,7 @@ var Tracker = class {
       console.warn("[Outlit] Tracking not enabled. Call enableTracking() first.");
       return;
     }
-    const event = (0, import_core2.buildIdentifyEvent)({
+    const event = (0, import_core3.buildIdentifyEvent)({
       url: window.location.href,
       referrer: document.referrer,
       email: options.email,
@@ -304,7 +752,7 @@ var Tracker = class {
     await this.sendEvents(events);
   }
   /**
-   * Shutdown the tracker.
+   * Shutdown the client.
    */
   async shutdown() {
     if (this.flushTimer) {
@@ -312,14 +760,26 @@ var Tracker = class {
       this.flushTimer = null;
     }
     stopAutocapture();
+    stopCalendarTracking();
+    stopSessionTracking();
+    this.sessionTracker = null;
     await this.flush();
   }
   // ============================================
   // INTERNAL METHODS
   // ============================================
+  initSessionTracking() {
+    this.sessionTracker = initSessionTracking({
+      onEngagement: (event) => {
+        this.enqueue(event);
+      },
+      idleTimeout: this.options.idleTimeout
+    });
+  }
   initPageviewTracking() {
     initPageviewTracking((url, referrer, title) => {
-      const event = (0, import_core2.buildPageviewEvent)({ url, referrer, title });
+      this.sessionTracker?.onNavigation(url);
+      const event = (0, import_core3.buildPageviewEvent)({ url, referrer, title });
       this.enqueue(event);
     });
   }
@@ -336,7 +796,7 @@ var Tracker = class {
     } : void 0;
     initFormTracking(
       (url, formId, fields) => {
-        const event = (0, import_core2.buildFormEvent)({
+        const event = (0, import_core3.buildFormEvent)({
           url,
           referrer: document.referrer,
           formId,
@@ -348,6 +808,25 @@ var Tracker = class {
       identityCallback2
     );
   }
+  initCalendarTracking() {
+    initCalendarTracking({
+      onCalendarBooked: (bookingEvent) => {
+        const event = (0, import_core3.buildCalendarEvent)({
+          url: window.location.href,
+          referrer: document.referrer,
+          provider: bookingEvent.provider,
+          eventType: bookingEvent.eventType,
+          startTime: bookingEvent.startTime,
+          endTime: bookingEvent.endTime,
+          duration: bookingEvent.duration,
+          isRecurring: bookingEvent.isRecurring,
+          inviteeEmail: bookingEvent.inviteeEmail,
+          inviteeName: bookingEvent.inviteeName
+        });
+        this.enqueue(event);
+      }
+    });
+  }
   enqueue(event) {
     this.eventQueue.push(event);
     if (this.eventQueue.length >= 10) {
@@ -363,7 +842,7 @@ var Tracker = class {
   async sendEvents(events) {
     if (events.length === 0) return;
     if (!this.visitorId) return;
-    const payload = (0, import_core2.buildIngestPayload)(this.visitorId, "pixel", events);
+    const payload = (0, import_core3.buildIngestPayload)(this.visitorId, "client", events);
     const url = `${this.apiHost}/api/i/v1/${this.publicKey}/events`;
     try {
       if (typeof navigator !== "undefined" && navigator.sendBeacon) {
@@ -387,15 +866,15 @@ var Tracker = class {
 var instance = null;
 function init(options) {
   if (instance) {
-    console.warn("[Outlit] Tracker already initialized");
+    console.warn("[Outlit] Already initialized");
     return instance;
   }
-  instance = new Tracker(options);
+  instance = new Outlit(options);
   return instance;
 }
 function getInstance() {
   if (!instance) {
-    throw new Error("[Outlit] Tracker not initialized. Call init() first.");
+    throw new Error("[Outlit] Not initialized. Call init() first.");
   }
   return instance;
 }
@@ -418,13 +897,13 @@ var src_default = {
   track,
   identify,
   getInstance,
-  Tracker,
+  Outlit,
   enableTracking,
   isTrackingEnabled
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Tracker,
+  Outlit,
   enableTracking,
   getInstance,
   identify,