@prodact.ai/sdk 0.0.2 → 0.0.5

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,16 +17,1757 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  ProactiveBehaviorTracker: () => ProactiveBehaviorTracker,
   ProduckSDK: () => ProduckSDK,
-  createProduck: () => createProduck
+  SessionRecorder: () => SessionRecorder,
+  UserFlowTracker: () => UserFlowTracker,
+  createProduck: () => createProduck,
+  createSessionRecorder: () => createSessionRecorder,
+  createUserFlowTracker: () => createUserFlowTracker,
+  defaultProactiveConfig: () => defaultProactiveConfig
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/recording/utils.ts
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const randomPart = Math.random().toString(36).substring(2, 15);
+  return `rec_${timestamp}_${randomPart}`;
+}
+function getDeviceInfo() {
+  if (typeof window === "undefined") {
+    return {
+      userAgent: "unknown",
+      screenWidth: 0,
+      screenHeight: 0,
+      viewportWidth: 0,
+      viewportHeight: 0,
+      devicePixelRatio: 1,
+      language: "en",
+      platform: "unknown"
+    };
+  }
+  return {
+    userAgent: navigator.userAgent,
+    screenWidth: screen.width,
+    screenHeight: screen.height,
+    viewportWidth: window.innerWidth,
+    viewportHeight: window.innerHeight,
+    devicePixelRatio: window.devicePixelRatio || 1,
+    language: navigator.language,
+    platform: navigator.platform
+  };
+}
+var DEFAULT_PRIVACY_CONFIG = {
+  maskAllInputs: true,
+  maskAllText: false,
+  maskSelectors: [".sensitive", "[data-sensitive]", ".pii", "[data-pii]"],
+  blockSelectors: [".no-record", "[data-no-record]"],
+  maskInputTypes: ["password", "email", "tel", "credit-card"],
+  maskCharacter: "*"
+};
+var DEFAULT_PERFORMANCE_CONFIG = {
+  batchEvents: true,
+  batchSize: 50,
+  batchTimeout: 5e3,
+  compress: true,
+  mouseMoveThrottle: 50,
+  maxDuration: 30 * 60 * 1e3
+  // 30 minutes
+};
+var DEFAULT_CAPTURE_CONFIG = {
+  console: true,
+  network: false,
+  performance: false,
+  errors: true,
+  customEvents: true
+};
+function mergeConfig(userConfig) {
+  return {
+    enabled: userConfig?.enabled ?? false,
+    samplingRate: userConfig?.samplingRate ?? 1,
+    privacy: { ...DEFAULT_PRIVACY_CONFIG, ...userConfig?.privacy },
+    performance: { ...DEFAULT_PERFORMANCE_CONFIG, ...userConfig?.performance },
+    capture: { ...DEFAULT_CAPTURE_CONFIG, ...userConfig?.capture },
+    endpoint: userConfig?.endpoint ?? "",
+    onStart: userConfig?.onStart ?? (() => {
+    }),
+    onStop: userConfig?.onStop ?? (() => {
+    }),
+    onError: userConfig?.onError ?? (() => {
+    })
+  };
+}
+function shouldRecordSession(samplingRate) {
+  if (samplingRate >= 1) return true;
+  if (samplingRate <= 0) return false;
+  return Math.random() < samplingRate;
+}
+function compressEvents(events) {
+  try {
+    const json = JSON.stringify(events);
+    if (typeof btoa !== "undefined") {
+      return btoa(encodeURIComponent(json));
+    }
+    return json;
+  } catch (error) {
+    console.warn("[Recording] Failed to compress events:", error);
+    return JSON.stringify(events);
+  }
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function getCurrentUrl() {
+  if (!isBrowser()) return "";
+  return window.location.href;
+}
+
+// src/recording/recorder.ts
+var SessionRecorder = class {
+  constructor(config) {
+    this.state = "idle";
+    this.sessionId = null;
+    this.sdkSessionToken = null;
+    this.apiUrl = "";
+    this.sdkKey = null;
+    // Recording internals
+    this.stopRecording = null;
+    this.events = [];
+    this.eventCount = 0;
+    this.batchIndex = 0;
+    this.batchesSent = 0;
+    this.errorCount = 0;
+    this.startTime = null;
+    this.batchTimeout = null;
+    this.maxDurationTimeout = null;
+    // Cleanup handlers
+    this.consoleCleanup = null;
+    this.errorCleanup = null;
+    this.config = mergeConfig(config);
+  }
+  /**
+   * Initialize the recorder with SDK context
+   */
+  initialize(sdkSessionToken, apiUrl, sdkKey) {
+    this.sdkSessionToken = sdkSessionToken;
+    this.apiUrl = apiUrl;
+    this.sdkKey = sdkKey || null;
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = mergeConfig({ ...this.config, ...config });
+  }
+  /**
+   * Start recording session
+   */
+  async start() {
+    if (!isBrowser()) {
+      console.warn("[Recording] Cannot record outside browser environment");
+      return null;
+    }
+    if (!this.config.enabled) {
+      return null;
+    }
+    if (this.state === "recording") {
+      console.warn("[Recording] Already recording");
+      return this.sessionId;
+    }
+    if (!shouldRecordSession(this.config.samplingRate)) {
+      console.log("[Recording] Session not sampled for recording");
+      return null;
+    }
+    try {
+      const rrweb = await import("rrweb");
+      this.sessionId = generateSessionId();
+      this.events = [];
+      this.eventCount = 0;
+      this.batchIndex = 0;
+      this.batchesSent = 0;
+      this.errorCount = 0;
+      this.startTime = /* @__PURE__ */ new Date();
+      this.state = "recording";
+      const rrwebOptions = {
+        emit: (event) => this.handleEvent(event),
+        maskAllInputs: this.config.privacy.maskAllInputs,
+        maskTextSelector: this.config.privacy.maskSelectors?.join(",") || void 0,
+        blockSelector: this.config.privacy.blockSelectors?.join(",") || void 0,
+        maskInputOptions: {
+          password: true,
+          email: this.config.privacy.maskInputTypes?.includes("email"),
+          tel: this.config.privacy.maskInputTypes?.includes("tel")
+        },
+        sampling: {
+          mousemove: true,
+          mouseInteraction: true,
+          scroll: 150,
+          media: 800,
+          input: "last"
+        }
+      };
+      this.stopRecording = rrweb.record(rrwebOptions);
+      if (this.config.capture.console) {
+        this.setupConsoleCapture();
+      }
+      if (this.config.capture.errors) {
+        this.setupErrorCapture();
+      }
+      if (this.config.performance.maxDuration) {
+        this.maxDurationTimeout = setTimeout(() => {
+          console.log("[Recording] Max duration reached, stopping");
+          this.stop();
+        }, this.config.performance.maxDuration);
+      }
+      await this.sendSessionStart();
+      this.config.onStart(this.sessionId);
+      console.log("[Recording] Started session:", this.sessionId);
+      return this.sessionId;
+    } catch (error) {
+      console.error("[Recording] Failed to start:", error);
+      this.state = "idle";
+      this.config.onError(error instanceof Error ? error : new Error(String(error)));
+      return null;
+    }
+  }
+  /**
+   * Stop recording
+   */
+  async stop() {
+    if (this.state !== "recording" && this.state !== "paused") {
+      return;
+    }
+    try {
+      if (this.stopRecording) {
+        this.stopRecording();
+        this.stopRecording = null;
+      }
+      if (this.consoleCleanup) {
+        this.consoleCleanup();
+        this.consoleCleanup = null;
+      }
+      if (this.errorCleanup) {
+        this.errorCleanup();
+        this.errorCleanup = null;
+      }
+      if (this.batchTimeout) {
+        clearTimeout(this.batchTimeout);
+        this.batchTimeout = null;
+      }
+      if (this.maxDurationTimeout) {
+        clearTimeout(this.maxDurationTimeout);
+        this.maxDurationTimeout = null;
+      }
+      if (this.events.length > 0) {
+        await this.sendBatch(true);
+      }
+      await this.sendSessionEnd();
+      const sessionId = this.sessionId;
+      const eventCount = this.eventCount;
+      this.state = "stopped";
+      this.config.onStop(sessionId || "", eventCount);
+      console.log("[Recording] Stopped session:", sessionId, "Events:", eventCount);
+    } catch (error) {
+      console.error("[Recording] Error stopping:", error);
+      this.config.onError(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Pause recording
+   */
+  pause() {
+    if (this.state !== "recording") return;
+    this.state = "paused";
+    console.log("[Recording] Paused");
+  }
+  /**
+   * Resume recording
+   */
+  resume() {
+    if (this.state !== "paused") return;
+    this.state = "recording";
+    console.log("[Recording] Resumed");
+  }
+  /**
+   * Add a custom event to the recording
+   */
+  addCustomEvent(event) {
+    if (this.state !== "recording" || !this.config.capture.customEvents) return;
+    const customEvent = {
+      type: 5,
+      // rrweb custom event type
+      data: {
+        tag: "custom",
+        payload: event
+      },
+      timestamp: event.timestamp || Date.now()
+    };
+    this.handleEvent(customEvent);
+  }
+  /**
+   * Get current recording stats
+   */
+  getStats() {
+    const duration = this.startTime ? Date.now() - this.startTime.getTime() : 0;
+    return {
+      state: this.state,
+      sessionId: this.sessionId,
+      eventCount: this.eventCount,
+      startTime: this.startTime,
+      duration,
+      batchesSent: this.batchesSent,
+      errors: this.errorCount
+    };
+  }
+  /**
+   * Check if recording is active
+   */
+  isRecording() {
+    return this.state === "recording";
+  }
+  /**
+   * Get session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  // ============ Private Methods ============
+  /**
+   * Handle incoming event from rrweb
+   */
+  handleEvent(event) {
+    if (this.state !== "recording") return;
+    this.events.push(event);
+    this.eventCount++;
+    if (this.config.performance.batchEvents) {
+      if (this.events.length >= this.config.performance.batchSize) {
+        this.sendBatch();
+      } else if (!this.batchTimeout) {
+        this.batchTimeout = setTimeout(() => {
+          this.batchTimeout = null;
+          if (this.events.length > 0) {
+            this.sendBatch();
+          }
+        }, this.config.performance.batchTimeout);
+      }
+    } else {
+      this.sendBatch();
+    }
+  }
+  /**
+   * Send event batch to backend
+   */
+  async sendBatch(isFinal = false) {
+    if (this.events.length === 0) return;
+    const eventsToSend = [...this.events];
+    this.events = [];
+    const batch = {
+      sessionId: this.sessionId,
+      sdkSessionToken: this.sdkSessionToken,
+      events: eventsToSend,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      batchIndex: this.batchIndex++,
+      isFinal
+    };
+    try {
+      const endpoint = this.config.endpoint || `${this.apiUrl}/session-recordings/events`;
+      const headers = { "Content-Type": "application/json" };
+      if (this.sdkKey) {
+        headers["X-SDK-Key"] = this.sdkKey;
+      }
+      const body = this.config.performance.compress ? JSON.stringify({ ...batch, events: void 0, compressedEvents: compressEvents(eventsToSend) }) : JSON.stringify(batch);
+      await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body
+      });
+      this.batchesSent++;
+    } catch (error) {
+      console.error("[Recording] Failed to send batch:", error);
+      this.errorCount++;
+      this.events = [...eventsToSend, ...this.events];
+    }
+  }
+  /**
+   * Send session start notification
+   */
+  async sendSessionStart() {
+    const session = {
+      id: this.sessionId,
+      sdkSessionToken: this.sdkSessionToken,
+      startUrl: getCurrentUrl(),
+      startTime: this.startTime,
+      deviceInfo: getDeviceInfo()
+    };
+    try {
+      const endpoint = `${this.apiUrl}/session-recordings/start`;
+      const headers = { "Content-Type": "application/json" };
+      if (this.sdkKey) {
+        headers["X-SDK-Key"] = this.sdkKey;
+      }
+      await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(session)
+      });
+    } catch (error) {
+      console.error("[Recording] Failed to send session start:", error);
+    }
+  }
+  /**
+   * Send session end notification
+   */
+  async sendSessionEnd() {
+    try {
+      const endpoint = `${this.apiUrl}/session-recordings/end`;
+      const headers = { "Content-Type": "application/json" };
+      if (this.sdkKey) {
+        headers["X-SDK-Key"] = this.sdkKey;
+      }
+      await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          sessionId: this.sessionId,
+          endTime: (/* @__PURE__ */ new Date()).toISOString(),
+          eventCount: this.eventCount
+        })
+      });
+    } catch (error) {
+      console.error("[Recording] Failed to send session end:", error);
+    }
+  }
+  /**
+   * Setup console log capture
+   */
+  setupConsoleCapture() {
+    const originalConsole = {
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      error: console.error,
+      debug: console.debug
+    };
+    const captureConsole = (level) => {
+      return (...args) => {
+        originalConsole[level](...args);
+        if (args[0]?.toString().includes("[Recording]")) return;
+        const logEvent = {
+          level,
+          message: args.map(
+            (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+          ).join(" "),
+          timestamp: Date.now()
+        };
+        this.addCustomEvent({
+          type: "console",
+          data: logEvent
+        });
+      };
+    };
+    console.log = captureConsole("log");
+    console.info = captureConsole("info");
+    console.warn = captureConsole("warn");
+    console.error = captureConsole("error");
+    console.debug = captureConsole("debug");
+    this.consoleCleanup = () => {
+      console.log = originalConsole.log;
+      console.info = originalConsole.info;
+      console.warn = originalConsole.warn;
+      console.error = originalConsole.error;
+      console.debug = originalConsole.debug;
+    };
+  }
+  /**
+   * Setup error capture
+   */
+  setupErrorCapture() {
+    const errorHandler = (event) => {
+      const errorEvent = {
+        type: "error",
+        message: event.message,
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno,
+        timestamp: Date.now()
+      };
+      this.addCustomEvent({
+        type: "error",
+        data: errorEvent
+      });
+    };
+    const rejectionHandler = (event) => {
+      const errorEvent = {
+        type: "unhandledrejection",
+        message: event.reason?.message || String(event.reason),
+        stack: event.reason?.stack,
+        timestamp: Date.now()
+      };
+      this.addCustomEvent({
+        type: "error",
+        data: errorEvent
+      });
+    };
+    window.addEventListener("error", errorHandler);
+    window.addEventListener("unhandledrejection", rejectionHandler);
+    this.errorCleanup = () => {
+      window.removeEventListener("error", errorHandler);
+      window.removeEventListener("unhandledrejection", rejectionHandler);
+    };
+  }
+  /**
+   * Destroy the recorder
+   */
+  destroy() {
+    this.stop();
+    this.sessionId = null;
+    this.sdkSessionToken = null;
+    this.events = [];
+  }
+};
+function createSessionRecorder(config) {
+  return new SessionRecorder(config);
+}
+
+// src/proactive.ts
+var ProactiveBehaviorTracker = class {
+  constructor(config, callbacks) {
+    this.isTracking = false;
+    // Tracking state
+    this.scrollDepth = 0;
+    this.pageLoadTime = 0;
+    this.clickCount = 0;
+    this.lastActivityTime = 0;
+    this.currentUrl = "";
+    this.previousUrl = "";
+    // Trigger state
+    this.triggeredSet = /* @__PURE__ */ new Set();
+    this.lastTriggerTime = 0;
+    this.proactiveMessageCount = 0;
+    // Listeners
+    this.scrollHandler = null;
+    this.clickHandler = null;
+    this.mouseMoveHandler = null;
+    this.mouseLeaveHandler = null;
+    this.visibilityHandler = null;
+    // Timers
+    this.timeCheckInterval = null;
+    this.idleCheckInterval = null;
+    this.config = config;
+    this.callbacks = callbacks;
+  }
+  /**
+   * Start tracking user behavior
+   */
+  start() {
+    if (!this.config.enabled || this.isTracking) return;
+    if (typeof window === "undefined") return;
+    if (this.config.respectUserPreference) {
+      const optOut = localStorage.getItem("produck_proactive_optout");
+      if (optOut === "true") return;
+    }
+    this.isTracking = true;
+    this.pageLoadTime = Date.now();
+    this.lastActivityTime = Date.now();
+    this.currentUrl = window.location.href;
+    this.setupScrollTracking();
+    this.setupClickTracking();
+    this.setupIdleTracking();
+    this.setupExitIntentTracking();
+    this.setupTimeTracking();
+    this.setupPageChangeTracking();
+    console.log("[Produck] Proactive behavior tracking started");
+  }
+  /**
+   * Stop tracking
+   */
+  stop() {
+    if (!this.isTracking) return;
+    this.isTracking = false;
+    if (this.scrollHandler) {
+      window.removeEventListener("scroll", this.scrollHandler);
+    }
+    if (this.clickHandler) {
+      document.removeEventListener("click", this.clickHandler);
+    }
+    if (this.mouseMoveHandler) {
+      document.removeEventListener("mousemove", this.mouseMoveHandler);
+    }
+    if (this.mouseLeaveHandler) {
+      document.removeEventListener("mouseleave", this.mouseLeaveHandler);
+    }
+    if (this.visibilityHandler) {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+    }
+    if (this.timeCheckInterval) {
+      clearInterval(this.timeCheckInterval);
+    }
+    if (this.idleCheckInterval) {
+      clearInterval(this.idleCheckInterval);
+    }
+    console.log("[Produck] Proactive behavior tracking stopped");
+  }
+  /**
+   * Reset tracking state (e.g., on page change)
+   */
+  reset() {
+    this.scrollDepth = 0;
+    this.clickCount = 0;
+    this.pageLoadTime = Date.now();
+    this.lastActivityTime = Date.now();
+  }
+  /**
+   * Get current tracking stats
+   */
+  getStats() {
+    return {
+      scrollDepth: this.scrollDepth,
+      timeOnPage: Date.now() - this.pageLoadTime,
+      clickCount: this.clickCount,
+      idleTime: Date.now() - this.lastActivityTime,
+      proactiveMessageCount: this.proactiveMessageCount
+    };
+  }
+  /**
+   * Check if a trigger should fire
+   */
+  shouldTrigger(trigger) {
+    if (this.config.maxProactiveMessages && this.proactiveMessageCount >= this.config.maxProactiveMessages) {
+      return false;
+    }
+    if (this.config.globalCooldown && Date.now() - this.lastTriggerTime < this.config.globalCooldown) {
+      return false;
+    }
+    const triggerKey = `${trigger.type}-${trigger.threshold || "default"}`;
+    if (trigger.onlyOnce && this.triggeredSet.has(triggerKey)) {
+      return false;
+    }
+    const lastTriggerKey = `${triggerKey}-lastTime`;
+    const lastTime = parseInt(sessionStorage.getItem(lastTriggerKey) || "0", 10);
+    if (trigger.cooldown && Date.now() - lastTime < trigger.cooldown) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Fire a trigger
+   */
+  fireTrigger(trigger, context) {
+    if (!this.shouldTrigger(trigger)) return;
+    const triggerKey = `${trigger.type}-${trigger.threshold || "default"}`;
+    const lastTriggerKey = `${triggerKey}-lastTime`;
+    this.triggeredSet.add(triggerKey);
+    this.lastTriggerTime = Date.now();
+    this.proactiveMessageCount++;
+    sessionStorage.setItem(lastTriggerKey, Date.now().toString());
+    const message = trigger.message || this.getDefaultMessage(trigger.type, context);
+    this.callbacks.onTrigger(context, message);
+    if (this.callbacks.onMessage) {
+      this.callbacks.onMessage(message);
+    }
+    console.log("[Produck] Proactive trigger fired:", trigger.type, context);
+  }
+  /**
+   * Get default message for trigger type
+   */
+  getDefaultMessage(type, context) {
+    switch (type) {
+      case "scroll":
+        return `I see you're exploring the page! Is there something specific you're looking for?`;
+      case "time":
+        return `You've been here a while. Would you like some help finding what you need?`;
+      case "clicks":
+        return `Looks like you're navigating around. Can I help you find something?`;
+      case "idle":
+        return `Still there? Let me know if you have any questions!`;
+      case "exit":
+        return `Wait! Before you go, is there anything I can help you with?`;
+      case "pageChange":
+        return `I see you're exploring different pages. Need any guidance?`;
+      default:
+        return `How can I help you today?`;
+    }
+  }
+  /**
+   * Setup scroll depth tracking
+   */
+  setupScrollTracking() {
+    const scrollTriggers = this.config.triggers.filter((t) => t.type === "scroll" && t.enabled);
+    if (scrollTriggers.length === 0) return;
+    this.scrollHandler = () => {
+      const docHeight = document.documentElement.scrollHeight - window.innerHeight;
+      const scrollPercent = docHeight > 0 ? window.scrollY / docHeight * 100 : 0;
+      this.scrollDepth = Math.max(this.scrollDepth, scrollPercent);
+      this.lastActivityTime = Date.now();
+      scrollTriggers.forEach((trigger) => {
+        if (trigger.threshold && this.scrollDepth >= trigger.threshold) {
+          this.fireTrigger(trigger, {
+            triggerType: "scroll",
+            scrollDepth: this.scrollDepth,
+            currentUrl: window.location.href,
+            pageTitle: document.title
+          });
+        }
+      });
+    };
+    window.addEventListener("scroll", this.scrollHandler, { passive: true });
+  }
+  /**
+   * Setup click tracking
+   */
+  setupClickTracking() {
+    const clickTriggers = this.config.triggers.filter((t) => t.type === "clicks" && t.enabled);
+    if (clickTriggers.length === 0) return;
+    this.clickHandler = () => {
+      this.clickCount++;
+      this.lastActivityTime = Date.now();
+      clickTriggers.forEach((trigger) => {
+        if (trigger.threshold && this.clickCount >= trigger.threshold) {
+          this.fireTrigger(trigger, {
+            triggerType: "clicks",
+            clickCount: this.clickCount,
+            currentUrl: window.location.href,
+            pageTitle: document.title
+          });
+        }
+      });
+    };
+    document.addEventListener("click", this.clickHandler);
+  }
+  /**
+   * Setup idle tracking
+   */
+  setupIdleTracking() {
+    const idleTriggers = this.config.triggers.filter((t) => t.type === "idle" && t.enabled);
+    if (idleTriggers.length === 0) return;
+    this.mouseMoveHandler = () => {
+      this.lastActivityTime = Date.now();
+    };
+    document.addEventListener("mousemove", this.mouseMoveHandler, { passive: true });
+    this.idleCheckInterval = setInterval(() => {
+      const idleTime = Date.now() - this.lastActivityTime;
+      idleTriggers.forEach((trigger) => {
+        if (trigger.threshold && idleTime >= trigger.threshold) {
+          this.fireTrigger(trigger, {
+            triggerType: "idle",
+            idleTime,
+            currentUrl: window.location.href,
+            pageTitle: document.title
+          });
+        }
+      });
+    }, 1e3);
+  }
+  /**
+   * Setup exit intent tracking
+   */
+  setupExitIntentTracking() {
+    const exitTriggers = this.config.triggers.filter((t) => t.type === "exit" && t.enabled);
+    if (exitTriggers.length === 0) return;
+    this.mouseLeaveHandler = (e) => {
+      if (e.clientY <= 0) {
+        exitTriggers.forEach((trigger) => {
+          this.fireTrigger(trigger, {
+            triggerType: "exit",
+            currentUrl: window.location.href,
+            pageTitle: document.title
+          });
+        });
+      }
+    };
+    document.addEventListener("mouseleave", this.mouseLeaveHandler);
+  }
+  /**
+   * Setup time on page tracking
+   */
+  setupTimeTracking() {
+    const timeTriggers = this.config.triggers.filter((t) => t.type === "time" && t.enabled);
+    if (timeTriggers.length === 0) return;
+    this.timeCheckInterval = setInterval(() => {
+      const timeOnPage = Date.now() - this.pageLoadTime;
+      timeTriggers.forEach((trigger) => {
+        if (trigger.threshold && timeOnPage >= trigger.threshold) {
+          this.fireTrigger(trigger, {
+            triggerType: "time",
+            timeOnPage,
+            currentUrl: window.location.href,
+            pageTitle: document.title
+          });
+        }
+      });
+    }, 1e3);
+  }
+  /**
+   * Setup SPA page change tracking
+   */
+  setupPageChangeTracking() {
+    const pageTriggers = this.config.triggers.filter((t) => t.type === "pageChange" && t.enabled);
+    if (pageTriggers.length === 0) return;
+    this.visibilityHandler = () => {
+      if (document.visibilityState === "visible") {
+        const newUrl = window.location.href;
+        if (newUrl !== this.currentUrl) {
+          this.previousUrl = this.currentUrl;
+          this.currentUrl = newUrl;
+          this.scrollDepth = 0;
+          this.clickCount = 0;
+          this.pageLoadTime = Date.now();
+          pageTriggers.forEach((trigger) => {
+            this.fireTrigger(trigger, {
+              triggerType: "pageChange",
+              currentUrl: this.currentUrl,
+              previousUrl: this.previousUrl,
+              pageTitle: document.title
+            });
+          });
+        }
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+    window.addEventListener("popstate", () => {
+      const newUrl = window.location.href;
+      if (newUrl !== this.currentUrl) {
+        this.previousUrl = this.currentUrl;
+        this.currentUrl = newUrl;
+        pageTriggers.forEach((trigger) => {
+          this.fireTrigger(trigger, {
+            triggerType: "pageChange",
+            currentUrl: this.currentUrl,
+            previousUrl: this.previousUrl,
+            pageTitle: document.title
+          });
+        });
+      }
+    });
+  }
+  /**
+   * Manually trigger a proactive message (for custom integrations)
+   */
+  triggerManual(message, context) {
+    this.proactiveMessageCount++;
+    this.lastTriggerTime = Date.now();
+    const fullContext = {
+      triggerType: "time",
+      // default
+      currentUrl: window.location.href,
+      pageTitle: document.title,
+      ...context
+    };
+    this.callbacks.onTrigger(fullContext, message);
+    if (this.callbacks.onMessage) {
+      this.callbacks.onMessage(message);
+    }
+  }
+  /**
+   * Opt out of proactive messages
+   */
+  optOut() {
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem("produck_proactive_optout", "true");
+    }
+    this.stop();
+  }
+  /**
+   * Opt in to proactive messages
+   */
+  optIn() {
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem("produck_proactive_optout");
+    }
+    this.start();
+  }
+};
+var defaultProactiveConfig = {
+  enabled: false,
+  triggers: [
+    {
+      type: "scroll",
+      enabled: true,
+      threshold: 75,
+      // 75% scroll depth
+      onlyOnce: true,
+      cooldown: 6e4
+      // 1 minute
+    },
+    {
+      type: "time",
+      enabled: true,
+      threshold: 3e4,
+      // 30 seconds
+      onlyOnce: true
+    },
+    {
+      type: "idle",
+      enabled: true,
+      threshold: 6e4,
+      // 1 minute idle
+      cooldown: 12e4
+      // 2 minutes between
+    },
+    {
+      type: "exit",
+      enabled: true,
+      onlyOnce: true
+    }
+  ],
+  maxProactiveMessages: 3,
+  globalCooldown: 3e4,
+  // 30 seconds between any proactive message
+  respectUserPreference: true
+};
+
+// src/user-flows/utils.ts
+function isBrowser2() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function generateSessionId2() {
+  return "ufs_" + Date.now().toString(36) + "_" + Math.random().toString(36).substring(2, 11);
+}
+function getCurrentUrl2() {
+  if (!isBrowser2()) return "";
+  return window.location.href;
+}
+function getCurrentPath() {
+  if (!isBrowser2()) return "";
+  return window.location.pathname;
+}
+function getCurrentTitle() {
+  if (!isBrowser2()) return "";
+  return document.title || "";
+}
+function shouldTrackSession(samplingRate = 1) {
+  return Math.random() < samplingRate;
+}
+function getDeviceInfo2() {
+  if (!isBrowser2()) {
+    return {
+      deviceType: "desktop",
+      browser: "unknown",
+      os: "unknown",
+      viewportWidth: 0,
+      viewportHeight: 0,
+      userAgent: ""
+    };
+  }
+  const ua = navigator.userAgent;
+  let deviceType = "desktop";
+  if (/Mobi|Android/i.test(ua)) {
+    deviceType = /Tablet|iPad/i.test(ua) ? "tablet" : "mobile";
+  }
+  let browser = "unknown";
+  if (ua.includes("Firefox")) browser = "Firefox";
+  else if (ua.includes("Edg")) browser = "Edge";
+  else if (ua.includes("Chrome")) browser = "Chrome";
+  else if (ua.includes("Safari")) browser = "Safari";
+  else if (ua.includes("Opera") || ua.includes("OPR")) browser = "Opera";
+  let os = "unknown";
+  if (ua.includes("Windows")) os = "Windows";
+  else if (ua.includes("Mac OS")) os = "macOS";
+  else if (ua.includes("Linux")) os = "Linux";
+  else if (ua.includes("Android")) os = "Android";
+  else if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad")) os = "iOS";
+  return {
+    deviceType,
+    browser,
+    os,
+    viewportWidth: window.innerWidth,
+    viewportHeight: window.innerHeight,
+    userAgent: ua
+  };
+}
+function getElementSelector(element, depth = 5) {
+  const parts = [];
+  let current = element;
+  let currentDepth = 0;
+  while (current && current !== document.body && currentDepth < depth) {
+    let selector = current.tagName.toLowerCase();
+    if (current.id) {
+      selector += `#${current.id}`;
+      parts.unshift(selector);
+      break;
+    }
+    if (current.className && typeof current.className === "string") {
+      const classes = current.className.trim().split(/\s+/);
+      if (classes.length > 0 && classes[0]) {
+        selector += `.${classes[0]}`;
+      }
+    }
+    const parent = current.parentElement;
+    if (parent) {
+      const siblings = Array.from(parent.children).filter(
+        (child) => child.tagName === current.tagName
+      );
+      if (siblings.length > 1) {
+        const index = siblings.indexOf(current) + 1;
+        selector += `:nth-child(${index})`;
+      }
+    }
+    parts.unshift(selector);
+    current = current.parentElement;
+    currentDepth++;
+  }
+  return parts.join(" > ");
+}
+function getElementXPath(element) {
+  if (!element) return "";
+  if (element.id) {
+    return `//*[@id="${element.id}"]`;
+  }
+  const parts = [];
+  let current = element;
+  while (current && current.nodeType === Node.ELEMENT_NODE) {
+    let index = 0;
+    let sibling = current.previousElementSibling;
+    while (sibling) {
+      if (sibling.tagName === current.tagName) {
+        index++;
+      }
+      sibling = sibling.previousElementSibling;
+    }
+    const tagName = current.tagName.toLowerCase();
+    const part = index > 0 ? `${tagName}[${index + 1}]` : tagName;
+    parts.unshift(part);
+    current = current.parentElement;
+  }
+  return "/" + parts.join("/");
+}
+function getElementInfo(element, config = {}) {
+  const maxTextLength = config?.maxTextLength || 100;
+  const maxHtmlLength = config?.maxHtmlLength || 500;
+  const selectorDepth = config?.selectorDepth || 5;
+  let text = "";
+  if (element instanceof HTMLElement) {
+    text = element.innerText || element.textContent || "";
+    text = text.trim().substring(0, maxTextLength);
+    if (text.length === maxTextLength) text += "...";
+  }
+  let html;
+  if (config?.captureHtml !== false) {
+    html = element.outerHTML.substring(0, maxHtmlLength);
+    if (html.length === maxHtmlLength) html += "...";
+  }
+  const rect = element.getBoundingClientRect();
+  const info = {
+    tag: element.tagName.toLowerCase(),
+    selector: getElementSelector(element, selectorDepth)
+  };
+  if (element.id) info.id = element.id;
+  if (element.className && typeof element.className === "string") {
+    info.className = element.className;
+  }
+  if (text) info.text = text;
+  if (element instanceof HTMLAnchorElement && element.href) {
+    info.href = element.href;
+  }
+  info.xpath = getElementXPath(element);
+  info.rect = {
+    x: Math.round(rect.x),
+    y: Math.round(rect.y),
+    width: Math.round(rect.width),
+    height: Math.round(rect.height)
+  };
+  if (html) info.html = html;
+  return info;
+}
+function matchesSelectors(element, selectors) {
+  if (!selectors || selectors.length === 0) return false;
+  return selectors.some((selector) => {
+    try {
+      return element.matches(selector) || element.closest(selector) !== null;
+    } catch {
+      return false;
+    }
+  });
+}
+function captureElementVisualInfo(element) {
+  try {
+    if (typeof window === "undefined") return void 0;
+    const htmlElement = element;
+    const styles = window.getComputedStyle(htmlElement);
+    return {
+      backgroundColor: styles.backgroundColor,
+      color: styles.color,
+      fontSize: styles.fontSize,
+      fontWeight: styles.fontWeight,
+      borderRadius: styles.borderRadius,
+      border: styles.border,
+      boxShadow: styles.boxShadow,
+      padding: styles.padding
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function captureElementScreenshot(element, maxSize = 200) {
+  try {
+    if (typeof window === "undefined") return void 0;
+    const html2canvas = window.html2canvas;
+    if (!html2canvas) {
+      try {
+        const module2 = await import(
+          /* webpackIgnore: true */
+          "html2canvas"
+        );
+        const canvas2 = await module2.default(element, {
+          scale: 0.5,
+          width: maxSize,
+          height: maxSize,
+          useCORS: true,
+          logging: false
+        });
+        return canvas2.toDataURL("image/jpeg", 0.7);
+      } catch {
+        console.debug("[UserFlow] html2canvas not available for screenshots");
+        return void 0;
+      }
+    }
+    const canvas = await html2canvas(element, {
+      scale: 0.5,
+      width: maxSize,
+      height: maxSize,
+      useCORS: true,
+      logging: false
+    });
+    return canvas.toDataURL("image/jpeg", 0.7);
+  } catch (error) {
+    console.debug("[UserFlow] Failed to capture screenshot:", error);
+    return void 0;
+  }
+}
+function mergeConfig2(config) {
+  const defaults = {
+    enabled: false,
+    samplingRate: 1,
+    events: {
+      clicks: true,
+      navigation: true,
+      formSubmit: true,
+      inputs: false,
+      scroll: false,
+      ignoreSelectors: [],
+      trackOnlySelectors: []
+    },
+    element: {
+      captureVisualStyles: true,
+      // Lightweight - enabled by default
+      captureScreenshot: false,
+      // Expensive - disabled by default
+      screenshotMaxSize: 200,
+      captureHtml: true,
+      maxHtmlLength: 500,
+      maxTextLength: 100,
+      selectorDepth: 5
+    },
+    performance: {
+      batchEvents: true,
+      batchSize: 10,
+      batchTimeout: 5e3,
+      clickDebounce: 500
+    },
+    session: {
+      endOnHidden: true,
+      inactivityTimeout: 5 * 60 * 1e3,
+      // 5 minutes
+      endOnExternalNavigation: true,
+      autoRestart: true
+    },
+    endpoint: "",
+    onStart: () => {
+    },
+    onStop: () => {
+    },
+    onError: () => {
+    }
+  };
+  if (!config) return defaults;
+  return {
+    enabled: config.enabled ?? defaults.enabled,
+    samplingRate: config.samplingRate ?? defaults.samplingRate,
+    events: { ...defaults.events, ...config.events },
+    element: { ...defaults.element, ...config.element },
+    performance: { ...defaults.performance, ...config.performance },
+    session: { ...defaults.session, ...config.session },
+    endpoint: config.endpoint ?? defaults.endpoint,
+    onStart: config.onStart ?? defaults.onStart,
+    onStop: config.onStop ?? defaults.onStop,
+    onError: config.onError ?? defaults.onError
+  };
+}
+
+// src/user-flows/tracker.ts
+var UserFlowTracker = class {
+  constructor(config) {
+    this.state = "idle";
+    this.sessionId = null;
+    this.sdkSessionToken = null;
+    this.apiUrl = "";
+    this.sdkKey = null;
+    this.user = null;
+    // Tracking internals
+    this.events = [];
+    this.eventCount = 0;
+    this.batchIndex = 0;
+    this.batchesSent = 0;
+    this.pageCount = 0;
+    this.startTime = null;
+    this.batchTimeout = null;
+    this.inactivityTimeout = null;
+    this.lastActivityTime = Date.now();
+    this.lastClickTime = 0;
+    this.lastClickElement = null;
+    this.currentPath = "";
+    this.visitedPaths = /* @__PURE__ */ new Set();
+    // Event listeners
+    this.clickHandler = null;
+    this.navigationHandler = null;
+    this.formSubmitHandler = null;
+    this.beforeUnloadHandler = null;
+    this.visibilityHandler = null;
+    // Linked recording session ID (if rrweb is also recording)
+    this.linkedRecordingSessionId = null;
+    this.config = mergeConfig2(config);
+  }
+  /**
+   * Initialize the tracker with SDK context
+   */
+  initialize(sdkSessionToken, apiUrl, sdkKey) {
+    this.sdkSessionToken = sdkSessionToken;
+    this.apiUrl = apiUrl;
+    this.sdkKey = sdkKey || null;
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = mergeConfig2({ ...this.config, ...config });
+  }
+  /**
+   * Identify the user
+   */
+  identify(user) {
+    this.user = user;
+    if (this.state === "tracking" && this.sessionId) {
+      this.sendIdentificationUpdate().catch((err) => {
+        console.error("[UserFlow] Failed to send identification update:", err);
+      });
+    }
+  }
+  /**
+   * Start tracking
+   * @param linkedRecordingSessionId - Optional linked rrweb session ID for playback
+   */
+  async start(linkedRecordingSessionId) {
+    if (!isBrowser2()) {
+      console.warn("[UserFlow] Cannot track outside browser environment");
+      return null;
+    }
+    if (!this.config.enabled) {
+      return null;
+    }
+    if (this.state === "tracking") {
+      console.warn("[UserFlow] Already tracking");
+      return this.sessionId;
+    }
+    if (!shouldTrackSession(this.config.samplingRate)) {
+      console.log("[UserFlow] Session not sampled for tracking");
+      return null;
+    }
+    try {
+      this.sessionId = generateSessionId2();
+      this.linkedRecordingSessionId = linkedRecordingSessionId || null;
+      this.events = [];
+      this.eventCount = 0;
+      this.batchIndex = 0;
+      this.batchesSent = 0;
+      this.pageCount = 1;
+      this.startTime = /* @__PURE__ */ new Date();
+      this.currentPath = getCurrentPath();
+      this.visitedPaths = /* @__PURE__ */ new Set([this.currentPath]);
+      this.state = "tracking";
+      this.setupEventListeners();
+      await this.sendSessionStart();
+      this.addEvent({
+        eventType: "navigation",
+        eventOrder: 0,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        pageUrl: getCurrentUrl2(),
+        pageTitle: getCurrentTitle(),
+        pagePath: this.currentPath
+      });
+      this.config.onStart(this.sessionId);
+      console.log("[UserFlow] Started tracking session:", this.sessionId);
+      return this.sessionId;
+    } catch (error) {
+      console.error("[UserFlow] Failed to start tracking:", error);
+      this.state = "idle";
+      this.config.onError(error instanceof Error ? error : new Error(String(error)));
+      return null;
+    }
+  }
+  /**
+   * Stop tracking
+   */
+  async stop() {
+    if (this.state !== "tracking" && this.state !== "paused") {
+      return;
+    }
+    try {
+      this.removeEventListeners();
+      if (this.batchTimeout) {
+        clearTimeout(this.batchTimeout);
+        this.batchTimeout = null;
+      }
+      if (this.inactivityTimeout) {
+        clearTimeout(this.inactivityTimeout);
+        this.inactivityTimeout = null;
+      }
+      if (this.events.length > 0) {
+        await this.sendEventBatch(true);
+      }
+      await this.sendSessionEnd();
+      this.state = "stopped";
+      const eventCount = this.eventCount;
+      const sessionId = this.sessionId;
+      this.sessionId = null;
+      this.events = [];
+      this.eventCount = 0;
+      this.startTime = null;
+      this.config.onStop(sessionId, eventCount);
+      console.log("[UserFlow] Stopped tracking session:", sessionId);
+    } catch (error) {
+      console.error("[UserFlow] Error stopping tracking:", error);
+      this.state = "stopped";
+      this.config.onError(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Pause tracking
+   */
+  pause() {
+    if (this.state === "tracking") {
+      this.state = "paused";
+      console.log("[UserFlow] Tracking paused");
+    }
+  }
+  /**
+   * Resume tracking
+   */
+  resume() {
+    if (this.state === "paused") {
+      this.state = "tracking";
+      console.log("[UserFlow] Tracking resumed");
+    }
+  }
+  /**
+   * Get tracker statistics
+   */
+  getStats() {
+    return {
+      sessionId: this.sessionId,
+      state: this.state,
+      eventCount: this.eventCount,
+      pageCount: this.pageCount,
+      batchesSent: this.batchesSent,
+      duration: this.startTime ? Date.now() - this.startTime.getTime() : 0,
+      startTime: this.startTime
+    };
+  }
+  /**
+   * Get tracking state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Check if currently tracking
+   */
+  isTracking() {
+    return this.state === "tracking";
+  }
+  /**
+   * Add a custom event
+   */
+  addCustomEvent(data) {
+    if (this.state !== "tracking") return;
+    this.addEvent({
+      eventType: "custom",
+      eventOrder: this.eventCount,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      pageUrl: getCurrentUrl2(),
+      pageTitle: getCurrentTitle(),
+      pagePath: getCurrentPath(),
+      metadata: data
+    });
+  }
+  // === Private methods ===
+  /**
+   * Setup event listeners
+   */
+  setupEventListeners() {
+    if (!isBrowser2()) return;
+    if (this.config.events.clicks) {
+      this.clickHandler = (e) => this.handleClick(e);
+      document.addEventListener("click", this.clickHandler, { capture: true, passive: true });
+    }
+    if (this.config.events.navigation) {
+      this.navigationHandler = () => this.handleNavigation();
+      window.addEventListener("popstate", this.navigationHandler);
+      const originalPushState = history.pushState;
+      const originalReplaceState = history.replaceState;
+      history.pushState = (...args) => {
+        originalPushState.apply(history, args);
+        this.handleNavigation();
+      };
+      history.replaceState = (...args) => {
+        originalReplaceState.apply(history, args);
+        this.handleNavigation();
+      };
+    }
+    if (this.config.events.formSubmit) {
+      this.formSubmitHandler = (e) => this.handleFormSubmit(e);
+      document.addEventListener("submit", this.formSubmitHandler, { capture: true });
+    }
+    this.beforeUnloadHandler = () => {
+      if (this.events.length > 0) {
+        this.sendEventBatchSync(true);
+      }
+      this.sendSessionEndSync();
+    };
+    window.addEventListener("beforeunload", this.beforeUnloadHandler);
+    this.visibilityHandler = () => {
+      if (document.visibilityState === "hidden") {
+        if (this.events.length > 0) {
+          this.sendEventBatch(true).catch(console.error);
+        }
+        if (this.config.session.endOnHidden) {
+          this.stop().catch(console.error);
+        }
+      } else if (document.visibilityState === "visible") {
+        if (this.config.session.autoRestart && this.state === "stopped") {
+          this.start().catch(console.error);
+        }
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+    this.resetInactivityTimeout();
+  }
+  /**
+   * Remove event listeners
+   */
+  removeEventListeners() {
+    if (!isBrowser2()) return;
+    if (this.clickHandler) {
+      document.removeEventListener("click", this.clickHandler, { capture: true });
+      this.clickHandler = null;
+    }
+    if (this.navigationHandler) {
+      window.removeEventListener("popstate", this.navigationHandler);
+      this.navigationHandler = null;
+    }
+    if (this.formSubmitHandler) {
+      document.removeEventListener("submit", this.formSubmitHandler, { capture: true });
+      this.formSubmitHandler = null;
+    }
+    if (this.beforeUnloadHandler) {
+      window.removeEventListener("beforeunload", this.beforeUnloadHandler);
+      this.beforeUnloadHandler = null;
+    }
+    if (this.visibilityHandler) {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
+  }
+  /**
+   * Handle click event
+   */
+  async handleClick(e) {
+    if (this.state !== "tracking") return;
+    const target = e.target;
+    if (!target || !(target instanceof Element)) return;
+    if (this.config.events.ignoreSelectors && this.config.events.ignoreSelectors.length > 0 && matchesSelectors(target, this.config.events.ignoreSelectors)) {
+      return;
+    }
+    if (this.config.events.trackOnlySelectors && this.config.events.trackOnlySelectors.length > 0 && !matchesSelectors(target, this.config.events.trackOnlySelectors)) {
+      return;
+    }
+    const now = Date.now();
+    if (this.lastClickElement === target && now - this.lastClickTime < this.config.performance.clickDebounce) {
+      return;
+    }
+    this.lastClickTime = now;
+    this.lastClickElement = target;
+    const elementInfo = getElementInfo(target, this.config.element);
+    if (this.config.element.captureVisualStyles) {
+      elementInfo.visualStyles = captureElementVisualInfo(target);
+    }
+    if (this.config.element.captureScreenshot) {
+      try {
+        elementInfo.screenshot = await captureElementScreenshot(
+          target,
+          this.config.element.screenshotMaxSize
+        );
+      } catch {
+      }
+    }
+    const event = {
+      eventType: "click",
+      eventOrder: this.eventCount,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      pageUrl: getCurrentUrl2(),
+      pageTitle: getCurrentTitle(),
+      pagePath: getCurrentPath(),
+      element: elementInfo,
+      clickX: Math.round(e.pageX),
+      clickY: Math.round(e.pageY),
+      viewportX: Math.round(e.clientX),
+      viewportY: Math.round(e.clientY)
+    };
+    this.addEvent(event);
+  }
+  /**
+   * Handle navigation event
+   */
+  handleNavigation() {
+    if (this.state !== "tracking") return;
+    const newPath = getCurrentPath();
+    if (newPath === this.currentPath) return;
+    this.currentPath = newPath;
+    if (!this.visitedPaths.has(newPath)) {
+      this.visitedPaths.add(newPath);
+      this.pageCount++;
+    }
+    const event = {
+      eventType: "navigation",
+      eventOrder: this.eventCount,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      pageUrl: getCurrentUrl2(),
+      pageTitle: getCurrentTitle(),
+      pagePath: newPath
+    };
+    this.addEvent(event);
+  }
+  /**
+   * Handle form submit event
+   */
+  handleFormSubmit(e) {
+    if (this.state !== "tracking") return;
+    const form = e.target;
+    if (!form || !(form instanceof HTMLFormElement)) return;
+    if (this.config.events.ignoreSelectors && matchesSelectors(form, this.config.events.ignoreSelectors)) {
+      return;
+    }
+    const elementInfo = getElementInfo(form, this.config.element);
+    const event = {
+      eventType: "form_submit",
+      eventOrder: this.eventCount,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      pageUrl: getCurrentUrl2(),
+      pageTitle: getCurrentTitle(),
+      pagePath: getCurrentPath(),
+      element: elementInfo,
+      metadata: {
+        action: form.action,
+        method: form.method,
+        name: form.name
+      }
+    };
+    this.addEvent(event);
+  }
+  /**
+   * Add event to queue
+   */
+  addEvent(event) {
+    this.events.push(event);
+    this.eventCount++;
+    this.resetInactivityTimeout();
+    if (this.config.performance.batchEvents && this.events.length >= this.config.performance.batchSize) {
+      this.sendEventBatch(false).catch(console.error);
+    } else if (!this.batchTimeout) {
+      this.batchTimeout = setTimeout(() => {
+        this.batchTimeout = null;
+        if (this.events.length > 0) {
+          this.sendEventBatch(false).catch(console.error);
+        }
+      }, this.config.performance.batchTimeout);
+    }
+  }
+  /**
+   * Send session start to backend
+   */
+  async sendSessionStart() {
+    const endpoint = this.config.endpoint || `${this.apiUrl}/user-flows/session/start`;
+    const device = getDeviceInfo2();
+    const body = {
+      sessionId: this.sessionId,
+      sdkSessionToken: this.sdkSessionToken,
+      startUrl: getCurrentUrl2(),
+      startTime: this.startTime?.toISOString(),
+      user: this.user,
+      device,
+      // Link to rrweb recording session if available
+      linkedRecordingSessionId: this.linkedRecordingSessionId
+    };
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.sdkKey ? { "X-SDK-Key": this.sdkKey } : {}
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to start session: ${response.status}`);
+    }
+  }
+  /**
+   * Send event batch to backend
+   */
+  async sendEventBatch(isFinal) {
+    if (this.events.length === 0) return;
+    const eventsToSend = [...this.events];
+    this.events = [];
+    const endpoint = this.config.endpoint ? `${this.config.endpoint}/events` : `${this.apiUrl}/user-flows/session/events`;
+    const body = {
+      sessionId: this.sessionId,
+      events: eventsToSend,
+      batchIndex: this.batchIndex++,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      isFinal
+    };
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.sdkKey ? { "X-SDK-Key": this.sdkKey } : {}
+        },
+        body: JSON.stringify(body)
+      });
+      if (response.ok) {
+        this.batchesSent++;
+      }
+    } catch (error) {
+      console.error("[UserFlow] Failed to send event batch:", error);
+      this.events = [...eventsToSend, ...this.events];
+    }
+  }
+  /**
+   * Send event batch synchronously (for beforeunload)
+   */
+  sendEventBatchSync(isFinal) {
+    if (this.events.length === 0) return;
+    const endpoint = this.config.endpoint ? `${this.config.endpoint}/events` : `${this.apiUrl}/user-flows/session/events`;
+    const body = {
+      sessionId: this.sessionId,
+      events: this.events,
+      batchIndex: this.batchIndex++,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      isFinal
+    };
+    if (navigator.sendBeacon) {
+      const blob = new Blob([JSON.stringify(body)], { type: "application/json" });
+      navigator.sendBeacon(endpoint, blob);
+      this.events = [];
+    }
+  }
+  /**
+   * Send session end to backend
+   */
+  async sendSessionEnd() {
+    const endpoint = this.config.endpoint ? `${this.config.endpoint}/end` : `${this.apiUrl}/user-flows/session/end`;
+    const body = {
+      sessionId: this.sessionId,
+      endTime: (/* @__PURE__ */ new Date()).toISOString(),
+      eventCount: this.eventCount,
+      status: "completed"
+    };
+    try {
+      await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.sdkKey ? { "X-SDK-Key": this.sdkKey } : {}
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (error) {
+      console.error("[UserFlow] Failed to send session end:", error);
+    }
+  }
+  /**
+   * Send session end synchronously (for beforeunload)
+   */
+  sendSessionEndSync() {
+    const endpoint = this.config.endpoint ? `${this.config.endpoint}/end` : `${this.apiUrl}/user-flows/session/end`;
+    const body = {
+      sessionId: this.sessionId,
+      endTime: (/* @__PURE__ */ new Date()).toISOString(),
+      eventCount: this.eventCount,
+      status: "completed"
+    };
+    if (navigator.sendBeacon) {
+      const blob = new Blob([JSON.stringify(body)], { type: "application/json" });
+      navigator.sendBeacon(endpoint, blob);
+    }
+  }
+  /**
+   * Reset inactivity timeout
+   * Called on each user interaction
+   */
+  resetInactivityTimeout() {
+    if (this.inactivityTimeout) {
+      clearTimeout(this.inactivityTimeout);
+      this.inactivityTimeout = null;
+    }
+    this.lastActivityTime = Date.now();
+    const timeout = this.config.session.inactivityTimeout;
+    if (timeout && timeout > 0) {
+      this.inactivityTimeout = setTimeout(() => {
+        if (this.state === "tracking") {
+          console.log("[UserFlow] Session ended due to inactivity");
+          this.stop().catch(console.error);
+        }
+      }, timeout);
+    }
+  }
+  /**
+   * Send identification update to backend
+   */
+  async sendIdentificationUpdate() {
+    if (!this.sessionId || !this.user) return;
+    const endpoint = this.config.endpoint ? `${this.config.endpoint}/identify` : `${this.apiUrl}/user-flows/session/identify`;
+    const body = {
+      sessionId: this.sessionId,
+      user: this.user
+    };
+    await fetch(endpoint, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.sdkKey ? { "X-SDK-Key": this.sdkKey } : {}
+      },
+      body: JSON.stringify(body)
+    });
+  }
+};
+function createUserFlowTracker(config) {
+  return new UserFlowTracker(config);
+}
+
 // src/core.ts
 var ProduckSDK = class {
   constructor(config) {
@@ -32,6 +1775,12 @@ var ProduckSDK = class {
     this.eventListeners = /* @__PURE__ */ new Map();
     this.sessionToken = null;
     this.isReady = false;
+    /** Session recorder instance (optional, isolated module) */
+    this.recorder = null;
+    /** Proactive behavior tracker instance (optional, isolated module) */
+    this.proactiveTracker = null;
+    /** User flow tracker instance (optional, isolated module) */
+    this.userFlowTracker = null;
     let apiUrl = config.apiUrl;
     if (!apiUrl) {
       if (typeof window !== "undefined") {
@@ -82,7 +1831,19 @@ var ProduckSDK = class {
       this.sessionToken = session.session_token;
       this.isReady = true;
       await this.log("info", "SDK initialized successfully", { hasSessionToken: !!this.sessionToken });
+      if (this.config.recording?.enabled) {
+        await this.initRecording();
+      }
+      if (this.config.proactive?.enabled) {
+        this.initProactive();
+      }
+      if (this.config.userFlows?.enabled) {
+        await this.initUserFlowTracking();
+      }
       this.emit("ready", { sessionToken: this.sessionToken });
+      if (this.config.initialMessage) {
+        await this.sendInitialMessage();
+      }
     } catch (error) {
       await this.log("error", "SDK initialization failed", { error: error instanceof Error ? error.message : String(error) });
       this.emit("error", error);
@@ -196,9 +1957,14 @@ var ProduckSDK = class {
       const result = await sessionResponse.json();
       const chatMessage = {
         role: "assistant",
-        content: result.message?.content || result.response || ""
+        content: result.message?.content || result.response || "",
+        visualFlows: result.flows || [],
+        images: result.images || []
       };
-      await this.log("info", "Chat response received");
+      await this.log("info", "Chat response received", {
+        hasFlows: (result.flows || []).length > 0,
+        hasImages: (result.images || []).length > 0
+      });
       this.emit("message", chatMessage);
       return chatMessage;
     } catch (error) {
@@ -488,10 +2254,387 @@ var ProduckSDK = class {
   getRegisteredActions() {
     return Array.from(this.actions.keys());
   }
+  /**
+   * Get guider ID for the current session
+   */
+  getGuiderId() {
+    return this.config.guiderId;
+  }
+  /**
+   * Fetch full visual flow details by flow ID
+   */
+  async getVisualFlow(flowId) {
+    const guiderId = this.config.guiderId;
+    if (!guiderId) {
+      await this.log("warn", "Cannot fetch visual flow without guiderId");
+      return null;
+    }
+    try {
+      const response = await fetch(
+        `${this.config.apiUrl}/visual-flows/chat/${guiderId}/${flowId}`
+      );
+      if (!response.ok) {
+        await this.log("warn", "Visual flow not found", { flowId, status: response.status });
+        return null;
+      }
+      const result = await response.json();
+      if (!result.found || !result.flow) {
+        return null;
+      }
+      return result.flow;
+    } catch (error) {
+      await this.log("error", "Error fetching visual flow", { flowId, error });
+      return null;
+    }
+  }
+  // ============================================================
+  // Session Recording Methods (Isolated Module)
+  // These methods delegate to the SessionRecorder when enabled
+  // ============================================================
+  /**
+   * Initialize session recording (internal)
+   */
+  async initRecording() {
+    try {
+      this.recorder = new SessionRecorder(this.config.recording);
+      this.recorder.initialize(
+        this.sessionToken,
+        this.config.apiUrl,
+        this.config.sdkKey
+      );
+      const sessionId = await this.recorder.start();
+      if (sessionId) {
+        await this.log("info", "Session recording started", { recordingSessionId: sessionId });
+      }
+    } catch (error) {
+      await this.log("warn", "Failed to initialize session recording", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Start session recording manually (if not auto-started)
+   */
+  async startRecording() {
+    if (!this.isReady) {
+      console.warn("[SDK] Cannot start recording before SDK is initialized");
+      return null;
+    }
+    if (!this.recorder) {
+      this.recorder = new SessionRecorder(this.config.recording);
+      this.recorder.initialize(
+        this.sessionToken,
+        this.config.apiUrl,
+        this.config.sdkKey
+      );
+    }
+    return this.recorder.start();
+  }
+  /**
+   * Stop session recording
+   */
+  async stopRecording() {
+    if (this.recorder) {
+      await this.recorder.stop();
+    }
+  }
+  /**
+   * Pause session recording
+   */
+  pauseRecording() {
+    this.recorder?.pause();
+  }
+  /**
+   * Resume session recording
+   */
+  resumeRecording() {
+    this.recorder?.resume();
+  }
+  /**
+   * Add a custom event to the recording
+   */
+  addRecordingEvent(event) {
+    this.recorder?.addCustomEvent(event);
+  }
+  /**
+   * Get recording statistics
+   */
+  getRecordingStats() {
+    return this.recorder?.getStats() ?? null;
+  }
+  /**
+   * Check if session recording is active
+   */
+  isRecordingActive() {
+    return this.recorder?.isRecording() ?? false;
+  }
+  /**
+   * Get recording session ID
+   */
+  getRecordingSessionId() {
+    return this.recorder?.getSessionId() ?? null;
+  }
+  // ============================================================
+  // Proactive Chat Methods (Isolated Module)
+  // These methods manage proactive behavior tracking and messaging
+  // ============================================================
+  /**
+   * Initialize proactive behavior tracking (internal)
+   */
+  initProactive() {
+    if (!this.config.proactive) return;
+    this.proactiveTracker = new ProactiveBehaviorTracker(
+      this.config.proactive,
+      {
+        onTrigger: async (context, suggestedMessage) => {
+          this.emit("proactive", { context, message: suggestedMessage });
+          if (this.config.onProactiveMessage) {
+            this.config.onProactiveMessage(suggestedMessage, context);
+          }
+          try {
+            await this.getProactiveAIMessage(context, suggestedMessage);
+          } catch (error) {
+            await this.log("warn", "Failed to get AI proactive message", { error });
+          }
+        }
+      }
+    );
+    this.proactiveTracker.start();
+    this.log("info", "Proactive behavior tracking initialized");
+  }
+  /**
+   * Get AI-generated proactive message based on context
+   */
+  async getProactiveAIMessage(context, fallbackMessage) {
+    try {
+      const headers = { "Content-Type": "application/json" };
+      if (this.config.sdkKey) {
+        headers["X-SDK-Key"] = this.config.sdkKey;
+      }
+      const response = await fetch(`${this.config.apiUrl}/sdk/proactive-message`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          context,
+          fallbackMessage,
+          sessionToken: this.sessionToken
+        })
+      });
+      if (!response.ok) {
+        return fallbackMessage;
+      }
+      const result = await response.json();
+      const message = result.message || fallbackMessage;
+      const chatMessage = {
+        role: "assistant",
+        content: message
+      };
+      this.emit("message", chatMessage);
+      return message;
+    } catch (error) {
+      return fallbackMessage;
+    }
+  }
+  /**
+   * Send initial message for landing page intros
+   */
+  async sendInitialMessage() {
+    const message = this.config.initialMessage;
+    if (!message) return;
+    if (this.config.streamInitialMessage) {
+      await this.streamMessage(message);
+    } else {
+      const chatMessage = {
+        role: "assistant",
+        content: message
+      };
+      this.emit("message", chatMessage);
+      if (this.config.onMessage) {
+        this.config.onMessage(chatMessage);
+      }
+    }
+  }
+  /**
+   * Stream a message character by character for typewriter effect
+   */
+  async streamMessage(message, delayMs = 30) {
+    let currentContent = "";
+    for (let i = 0; i < message.length; i++) {
+      currentContent += message[i];
+      const chatMessage = {
+        role: "assistant",
+        content: currentContent
+      };
+      this.emit("message", chatMessage);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  /**
+   * Start proactive tracking manually
+   */
+  startProactiveTracking() {
+    if (this.proactiveTracker) {
+      this.proactiveTracker.start();
+    }
+  }
+  /**
+   * Stop proactive tracking
+   */
+  stopProactiveTracking() {
+    if (this.proactiveTracker) {
+      this.proactiveTracker.stop();
+    }
+  }
+  /**
+   * Get proactive tracking stats
+   */
+  getProactiveStats() {
+    return this.proactiveTracker?.getStats() ?? null;
+  }
+  /**
+   * Manually trigger a proactive message
+   */
+  triggerProactiveMessage(message, context) {
+    if (this.proactiveTracker) {
+      this.proactiveTracker.triggerManual(message, context);
+    } else {
+      const chatMessage = {
+        role: "assistant",
+        content: message
+      };
+      this.emit("message", chatMessage);
+      if (this.config.onMessage) {
+        this.config.onMessage(chatMessage);
+      }
+    }
+  }
+  /**
+   * Opt out of proactive messages (respects user preference)
+   */
+  optOutProactive() {
+    this.proactiveTracker?.optOut();
+  }
+  /**
+   * Opt in to proactive messages
+   */
+  optInProactive() {
+    this.proactiveTracker?.optIn();
+  }
+  // ============================================================
+  // User Flow Tracking Methods (Isolated Module)
+  // These methods manage user interaction tracking and flow analysis
+  // ============================================================
+  /**
+   * Initialize user flow tracking (internal)
+   */
+  async initUserFlowTracking() {
+    try {
+      this.userFlowTracker = new UserFlowTracker(this.config.userFlows);
+      this.userFlowTracker.initialize(
+        this.sessionToken,
+        this.config.apiUrl,
+        this.config.sdkKey
+      );
+      const recordingSessionId = this.recorder?.getSessionId?.() || null;
+      const sessionId = await this.userFlowTracker.start(recordingSessionId);
+      if (sessionId) {
+        await this.log("info", "User flow tracking started", {
+          flowSessionId: sessionId,
+          linkedRecordingSession: recordingSessionId
+        });
+      }
+    } catch (error) {
+      await this.log("warn", "Failed to initialize user flow tracking", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Identify the user for flow tracking and segmentation
+   * Call this when you know who the user is (e.g., after login)
+   */
+  identify(user) {
+    if (this.userFlowTracker) {
+      this.userFlowTracker.identify(user);
+    }
+    this.log("info", "User identified", {
+      hasEmail: !!user.email,
+      hasName: !!user.name,
+      hasTags: !!user.tags && Object.keys(user.tags).length > 0
+    });
+  }
+  /**
+   * Start user flow tracking manually (if not auto-started)
+   */
+  async startUserFlowTracking() {
+    if (!this.isReady) {
+      console.warn("[SDK] Cannot start flow tracking before SDK is initialized");
+      return null;
+    }
+    if (!this.userFlowTracker) {
+      this.userFlowTracker = new UserFlowTracker(this.config.userFlows);
+      this.userFlowTracker.initialize(
+        this.sessionToken,
+        this.config.apiUrl,
+        this.config.sdkKey
+      );
+    }
+    return this.userFlowTracker.start();
+  }
+  /**
+   * Stop user flow tracking
+   */
+  async stopUserFlowTracking() {
+    if (this.userFlowTracker) {
+      await this.userFlowTracker.stop();
+    }
+  }
+  /**
+   * Pause user flow tracking
+   */
+  pauseUserFlowTracking() {
+    this.userFlowTracker?.pause();
+  }
+  /**
+   * Resume user flow tracking
+   */
+  resumeUserFlowTracking() {
+    this.userFlowTracker?.resume();
+  }
+  /**
+   * Add a custom event to the user flow
+   */
+  trackEvent(eventData) {
+    this.userFlowTracker?.addCustomEvent(eventData);
+  }
+  /**
+   * Get user flow tracking statistics
+   */
+  getUserFlowStats() {
+    return this.userFlowTracker?.getStats() ?? null;
+  }
+  /**
+   * Check if user flow tracking is active
+   */
+  isUserFlowTrackingActive() {
+    return this.userFlowTracker?.isTracking() ?? false;
+  }
   /**
    * Destroy the SDK instance
    */
   destroy() {
+    if (this.recorder) {
+      this.recorder.destroy();
+      this.recorder = null;
+    }
+    if (this.proactiveTracker) {
+      this.proactiveTracker.stop();
+      this.proactiveTracker = null;
+    }
+    if (this.userFlowTracker) {
+      this.userFlowTracker.stop();
+      this.userFlowTracker = null;
+    }
     this.actions.clear();
     this.eventListeners.clear();
     this.sessionToken = null;
@@ -503,7 +2646,13 @@ function createProduck(config) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ProactiveBehaviorTracker,
   ProduckSDK,
-  createProduck
+  SessionRecorder,
+  UserFlowTracker,
+  createProduck,
+  createSessionRecorder,
+  createUserFlowTracker,
+  defaultProactiveConfig
 });
 //# sourceMappingURL=index.js.map