@magicfeedback/popup-sdk 1.1.0 → 1.1.2

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -30,6 +33,117 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/tracking/tracking-manager.ts
+function createDefaultStorage() {
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      const ls = window.localStorage;
+      const probe = "__deepdots_probe__";
+      ls.setItem(probe, "1");
+      ls.removeItem(probe);
+      return {
+        getItem: (k) => ls.getItem(k),
+        setItem: (k, v) => ls.setItem(k, v),
+        removeItem: (k) => ls.removeItem(k)
+      };
+    }
+  } catch {
+  }
+  return new InMemoryStorage();
+}
+function buildSurveyIdentity(userId, sessionId, miniService = null, analyticsFeedbackSessionId = null) {
+  const profile = userId ? [{ key: "external-user-id", value: [userId] }] : [];
+  const metadata = [];
+  if (sessionId) metadata.push({ key: "session_id", value: [sessionId] });
+  if (userId) metadata.push({ key: "user_id", value: [userId] });
+  if (miniService) metadata.push({ key: "mini_service", value: [miniService] });
+  if (analyticsFeedbackSessionId) metadata.push({ key: "deepdots_analytics_feedback_session_id", value: [analyticsFeedbackSessionId] });
+  return { profile, metadata };
+}
+function defaultUuid() {
+  const g = typeof globalThis !== "undefined" ? globalThis : {};
+  if (g.crypto?.randomUUID) return g.crypto.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (g.crypto?.getRandomValues) {
+    g.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+var InMemoryStorage, STORAGE_KEYS, TrackingManager;
+var init_tracking_manager = __esm({
+  "src/tracking/tracking-manager.ts"() {
+    "use strict";
+    InMemoryStorage = class {
+      constructor() {
+        this.map = /* @__PURE__ */ new Map();
+      }
+      getItem(key) {
+        return this.map.has(key) ? this.map.get(key) : null;
+      }
+      setItem(key, value) {
+        this.map.set(key, value);
+      }
+      removeItem(key) {
+        this.map.delete(key);
+      }
+    };
+    STORAGE_KEYS = {
+      userId: "deepdots.user_id",
+      firstSeen: "deepdots.user.first_seen",
+      contactAttributes: "deepdots.contact.attributes"
+    };
+    TrackingManager = class {
+      constructor(options) {
+        /** session_id cacheado, provisto por el backend (no se genera ni se persiste). */
+        this.sessionId = null;
+        this.userWasJustCreated = false;
+        this.storage = options.storage;
+        this.clientUserId = options.clientUserId;
+        this.now = options.now ?? (() => Date.now());
+        this.uuid = options.uuid ?? defaultUuid;
+        this.enabled = options.enabled ?? true;
+      }
+      isTrackingEnabled() {
+        return this.enabled;
+      }
+      setTrackingEnabled(enabled) {
+        this.enabled = enabled;
+      }
+      /** Resuelve el user_id según la regla: cliente > persistido > generar+persistir. */
+      getUserId() {
+        if (!this.enabled) return null;
+        if (this.clientUserId) return this.clientUserId;
+        const persisted = this.storage.getItem(STORAGE_KEYS.userId);
+        if (persisted) return persisted;
+        const id = this.uuid();
+        this.storage.setItem(STORAGE_KEYS.userId, id);
+        this.storage.setItem(STORAGE_KEYS.firstSeen, String(this.now()));
+        this.userWasJustCreated = true;
+        return id;
+      }
+      /** `true` solo en la primera sesión tras crear el user_id propio del SDK. */
+      isNewUser() {
+        return this.userWasJustCreated;
+      }
+      /** session_id actual provisto por el backend, o null si aún no llegó. */
+      getSessionId() {
+        if (!this.enabled) return null;
+        return this.sessionId;
+      }
+      /** Cachea el session_id devuelto por el backend (respuesta de POST /sdk/popups). */
+      setSessionId(sessionId) {
+        if (!this.enabled) return;
+        this.sessionId = sessionId;
+      }
+    };
+  }
+});
+
 // node_modules/@magicfeedback/native/dist/magicfeedback-sdk.browser.js
 var require_magicfeedback_sdk_browser = __commonJS({
   "node_modules/@magicfeedback/native/dist/magicfeedback-sdk.browser.js"(exports, module2) {
@@ -1955,26 +2069,11 @@ var require_magicfeedback_sdk_browser = __commonJS({
   }
 });
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DeepdotsPopups: () => DeepdotsPopups,
-  POPUP_TRIGGER_CONDITION_STATUSES: () => POPUP_TRIGGER_CONDITION_STATUSES
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/types/index.ts
-var POPUP_TRIGGER_CONDITION_STATUSES = [
-  "SHOWED",
-  "PARTIAL",
-  "COMPLETED"
-];
-
-// src/ui/renderPopup.ts
-var import_native = __toESM(require_magicfeedback_sdk_browser());
-
 // src/assets/style.css
-var style_default = `.magicfeedback-container {
+var style_default;
+var init_style = __esm({
+  "src/assets/style.css"() {
+    style_default = `.magicfeedback-container {
     width: 100%;
 }
 
@@ -2828,8 +2927,14 @@ var style_default = `.magicfeedback-container {
 .magicfeedback-error{
     margin-top: 5px;
 }`;
+  }
+});
 
 // src/ui/renderPopup.ts
+var renderPopup_exports = {};
+__export(renderPopup_exports, {
+  renderPopup: () => renderPopup
+});
 function ensureMagicFeedbackStyles(_popup) {
   const STYLE_ID = "magicfeedback-sdk-styles";
   if (document.getElementById(STYLE_ID)) return;
@@ -2887,7 +2992,7 @@ function ensureResponsiveStyles(_popup) {
   `;
   document.head.appendChild(style);
 }
-async function renderPopup(container, surveyId, productId, actions, emit, onClose, env = "production", userId, style) {
+async function renderPopup(container, surveyId, productId, actions, emit, onClose, env = "production", userId, style, sessionId, miniService, analyticsFeedbackSessionId) {
   let surveyCompletedEmitted = false;
   let stylesInjected = false;
   const isDark = style?.theme === "dark";
@@ -3198,8 +3303,8 @@ async function renderPopup(container, surveyId, productId, actions, emit, onClos
         env: env === "production" ? "prod" : "dev"
       }
     );
-    const profile = userId ? [{ key: "external-user-id", value: [userId] }] : [];
-    formInstance = import_native.default.form(surveyId, productId, profile, profile);
+    const { profile, metadata } = buildSurveyIdentity(userId ?? null, sessionId ?? null, miniService ?? null, analyticsFeedbackSessionId ?? null);
+    formInstance = import_native.default.form(surveyId, productId, profile, metadata);
     const generateOptions = {
       addButton: false,
       getMetaData: true
@@ -3338,6 +3443,42 @@ async function renderPopup(container, surveyId, productId, actions, emit, onClos
     setLoading(false);
   }
 }
+var import_native;
+var init_renderPopup = __esm({
+  "src/ui/renderPopup.ts"() {
+    "use strict";
+    init_tracking_manager();
+    import_native = __toESM(require_magicfeedback_sdk_browser());
+    init_style();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BrowserPopupRenderer: () => BrowserPopupRenderer,
+  ContactManager: () => ContactManager,
+  DeepdotsPopups: () => DeepdotsPopups,
+  InMemoryStorage: () => InMemoryStorage,
+  NoopPopupRenderer: () => NoopPopupRenderer,
+  POPUP_TRIGGER_CONDITION_STATUSES: () => POPUP_TRIGGER_CONDITION_STATUSES,
+  ReactNativePopupRenderer: () => ReactNativePopupRenderer,
+  buildAnalyticsFeedbackBody: () => buildAnalyticsFeedbackBody,
+  buildSurveyHtml: () => buildSurveyHtml,
+  collectRnDevice: () => collectRnDevice,
+  createDefaultRenderer: () => createDefaultRenderer,
+  createFeedbackSink: () => createFeedbackSink,
+  mmkvStorage: () => mmkvStorage,
+  setupReactNative: () => setupReactNative
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/index.ts
+var POPUP_TRIGGER_CONDITION_STATUSES = [
+  "SHOWED",
+  "PARTIAL",
+  "COMPLETED"
+];
 
 // src/triggers/index.ts
 function setupTrigger(popups, trigger) {
@@ -3516,41 +3657,125 @@ function resolveEnvironment(nodeEnv) {
   return ENVIRONMENT_MAP[nodeEnv || "production"];
 }
 
+// src/platform/react-native-renderer.ts
+init_tracking_manager();
+
+// src/ui/surveyHtml.ts
+function buildSurveyHtml(opts) {
+  const env = opts.env === "development" ? "dev" : "prod";
+  const version = opts.version ?? "2.2.4";
+  const cdn = `https://cdn.jsdelivr.net/npm/@magicfeedback/native@${version}/dist/magicfeedback-sdk.browser.js`;
+  const sid = JSON.stringify(opts.surveyId);
+  const pid = JSON.stringify(opts.productId);
+  const profileJson = JSON.stringify(opts.profile ?? []);
+  const metaJson = JSON.stringify(opts.metadata ?? []);
+  return `<!DOCTYPE html><html><head>
+<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+<meta name="color-scheme" content="light"/>
+<style>html,body{margin:0;padding:0;background:transparent;font-family:-apple-system,system-ui,sans-serif}#mf{width:100%;box-sizing:border-box}#mf *{max-width:100%;box-sizing:border-box}</style>
+</head><body>
+<div id="mf"></div>
+<script>
+(function(){
+  function emit(s){ try{ if(window.ReactNativeWebView){ window.ReactNativeWebView.postMessage(s); } }catch(e){} }
+  function emitJSON(n,p){ try{ emit(JSON.stringify({name:n,payload:p||{}})); }catch(e){} }
+  window.DeepdotsClose = function(){ emitJSON('popup_close'); };
+  var initialized=false;
+  function initMF(){
+    if(initialized || !window.magicfeedback) return initialized;
+    initialized=true;
+    try{
+      window.magicfeedback.init({ debug:false, env:'${env}' });
+      var form = window.magicfeedback.form(${sid}, ${pid}, ${profileJson}, ${metaJson});
+      window.DeepdotsForm = form;
+      form.generate('mf', {
+        addButton:false,
+        getMetaData:true,
+        onLoadedEvent:function(){ emitJSON('loaded'); },
+        beforeSubmitEvent:function(){ emitJSON('before_submit'); },
+        afterSubmitEvent:function(p){
+          try{ if(p && p.completed){ emitJSON('survey_completed', p); } else { emitJSON('after_submit', p); } }
+          catch(e){ emitJSON('after_submit'); }
+        },
+        onBackEvent:function(p){ emitJSON('back', p); }
+      }).catch(function(e){ emit('error:init'); });
+    }catch(e){ emit('error:exception'); }
+    return true;
+  }
+  var s=document.createElement('script'); s.src=${JSON.stringify(cdn)}; s.async=true;
+  s.onload=function(){ initMF(); };
+  s.onerror=function(){ emit('error:load'); };
+  document.head.appendChild(s);
+  var tries=0, t=setInterval(function(){ if(initMF()||++tries>40){ clearInterval(t); } },150);
+})();
+<\/script>
+</body></html>`;
+}
+
 // src/platform/react-native-renderer.ts
 var ReactNativePopupRenderer = class {
-  constructor() {
-    this.mounted = false;
-    this.lastSurveyId = null;
+  constructor(options = {}) {
+    this.options = options;
     this.emitFn = null;
     this.onCloseFn = null;
-    this.completed = false;
+    this.currentSurveyId = null;
+    this.partialEmitted = false;
   }
   init() {
   }
-  show(surveyId, productId, data, emit, onClose) {
-    this.mounted = true;
-    this.lastSurveyId = surveyId;
+  show(surveyId, productId, _actions, emit, onClose, env = "production", userId, _style, sessionId, miniService, analyticsFeedbackSessionId) {
     this.emitFn = emit;
     this.onCloseFn = onClose;
-    this.completed = false;
-    queueMicrotask(() => emit("popup_clicked", surveyId, data));
-    console.log("[ReactNativePopupRenderer] (stub) show survey:", { surveyId, productId, data });
-  }
-  /** Completar la encuesta desde la capa nativa */
-  completeSurvey(data) {
-    if (!this.mounted || this.completed || !this.lastSurveyId || !this.emitFn) return;
-    this.completed = true;
-    this.emitFn("survey_completed", this.lastSurveyId, data);
-    this.onCloseFn?.();
-    this.mounted = false;
-    console.log("[ReactNativePopupRenderer] (stub) survey completed:", { surveyId: this.lastSurveyId, data });
-    this.lastSurveyId = null;
+    this.currentSurveyId = surveyId;
+    this.partialEmitted = false;
+    const { profile, metadata } = buildSurveyIdentity(userId ?? null, sessionId ?? null, miniService ?? null, analyticsFeedbackSessionId ?? null);
+    const html = buildSurveyHtml({ surveyId, productId, env, profile, metadata });
+    if (this.options.onShow) {
+      this.options.onShow({ surveyId, productId, html });
+    } else {
+      console.warn(
+        "[Deepdots] ReactNativePopupRenderer sin onShow: pasa { onShow } a new ReactNativePopupRenderer({...}) para montar el WebView del survey."
+      );
+    }
   }
   hide() {
-    if (!this.mounted) return;
-    this.mounted = false;
-    console.log("[ReactNativePopupRenderer] (stub) hide survey:", this.lastSurveyId);
-    this.lastSurveyId = null;
+    this.options.onHide?.();
+    this.currentSurveyId = null;
+  }
+  /**
+   * El host la conecta al `onMessage` del WebView. Traduce los mensajes del survey a
+   * eventos del SDK: primera interacción → `popup_clicked` (PARTIAL), completado →
+   * `survey_completed` (COMPLETED) y cierra el popup.
+   */
+  handleMessage(raw) {
+    const surveyId = this.currentSurveyId;
+    if (!surveyId || !this.emitFn) return;
+    let name;
+    try {
+      name = JSON.parse(raw).name;
+    } catch {
+      name = raw;
+    }
+    switch (name) {
+      case "loaded":
+      case "before_submit":
+      case "after_submit":
+      case "back":
+        if (!this.partialEmitted) {
+          this.partialEmitted = true;
+          this.emitFn("popup_clicked", surveyId, { action: "partial" });
+        }
+        break;
+      case "survey_completed":
+        this.emitFn("survey_completed", surveyId);
+        this.onCloseFn?.();
+        break;
+      case "popup_close":
+        this.onCloseFn?.();
+        break;
+      default:
+        break;
+    }
   }
 };
 function isReactNativeEnv() {
@@ -3594,12 +3819,15 @@ var BrowserPopupRenderer = class {
       document.body.appendChild(this.container);
     }
   }
-  show(surveyId, productId, actions, emit, onClose, env = "production", userId, style) {
+  show(surveyId, productId, actions, emit, onClose, env = "production", userId, style, sessionId, miniService, analyticsFeedbackSessionId) {
     if (this.visible) return;
     if (!this.container || !document.body.contains(this.container)) this.init();
     if (!this.container) return;
     this.visible = true;
-    renderPopup(this.container, surveyId, productId, actions, emit, onClose, env, userId, style);
+    const container = this.container;
+    void Promise.resolve().then(() => (init_renderPopup(), renderPopup_exports)).then(({ renderPopup: renderPopup2 }) => {
+      renderPopup2(container, surveyId, productId, actions, emit, onClose, env, userId, style, sessionId, miniService, analyticsFeedbackSessionId);
+    });
   }
   hide() {
     this.visible = false;
@@ -3618,9 +3846,418 @@ function createDefaultRenderer() {
   return new BrowserPopupRenderer();
 }
 
+// src/core/deepdots-popups.ts
+init_tracking_manager();
+
+// src/analytics/analytics-manager.ts
+var dryRunSink = (payload) => {
+  console.log(
+    "[DeepdotsAnalytics] (dry-run \xB7 NO enviado \xB7 sin init.analytics) POST /sdk/feedback \u2192",
+    JSON.stringify(payload, null, 2)
+  );
+};
+var AnalyticsManager = class {
+  constructor(options = {}) {
+    this.events = [];
+    this.attributes = {};
+    this.miniService = null;
+    this.miniServiceEnteredAt = 0;
+    this.sink = options.sink ?? dryRunSink;
+    this.now = options.now ?? (() => Date.now());
+    this.publicKey = options.publicKey;
+    this.language = options.language;
+    this.device = options.device;
+    this.platform = options.platform ?? "web";
+    this.maxBatchSize = options.maxBatchSize ?? 20;
+    this.onFlushNeeded = options.onFlushNeeded;
+  }
+  /** Actualiza campos de device en runtime (p.ej. country/city tras resolver geo). */
+  updateDevice(partial) {
+    this.device = { ...this.device, ...partial };
+  }
+  /** Mezcla user attributes (se coercionan a string). Mutable en runtime. */
+  setUserAttributes(attrs) {
+    for (const [k, v] of Object.entries(attrs)) {
+      if (!k) continue;
+      this.attributes[k] = String(v);
+    }
+  }
+  /** Marca el inicio de un mini-service; etiqueta los eventos siguientes con `mini_service`. */
+  enterMiniService(name, entryPointType) {
+    this.miniService = name;
+    this.miniServiceEnteredAt = this.now();
+    this.track("mini_service_enter", { entry_point_type: entryPointType ?? null });
+  }
+  /** Cierra el mini-service activo emitiendo `mini_service_exit` con su duración (#27). No-op si no hay ninguno. */
+  exitMiniService() {
+    const name = this.miniService;
+    if (name == null) return;
+    const durationSeconds = Math.max(0, Math.round((this.now() - this.miniServiceEnteredAt) / 1e3));
+    this.miniService = null;
+    this.track("mini_service_exit", { mini_service: name, duration_seconds: durationSeconds });
+  }
+  /** Registra un evento de analítica (modelo GA: nombre + params). */
+  track(name, params) {
+    const merged = {
+      ...this.miniService ? { mini_service: this.miniService } : {},
+      ...params ?? {}
+    };
+    this.events.push({
+      name,
+      timestamp: this.now(),
+      params: Object.keys(merged).length ? merged : void 0
+    });
+    if (this.events.length >= this.maxBatchSize) {
+      this.onFlushNeeded?.();
+    }
+  }
+  /** Mini-service activo (para inyectarlo en la metadata del survey, #33). */
+  getMiniService() {
+    return this.miniService;
+  }
+  /** Nº de eventos pendientes de flush. */
+  pending() {
+    return this.events.length;
+  }
+  /** Construye el envelope que se enviaría al endpoint de analytics. */
+  buildPayload(identity) {
+    return {
+      publicKey: this.publicKey,
+      userId: identity.userId,
+      sessionId: identity.sessionId,
+      context: {
+        platform: this.platform,
+        language: this.language,
+        device: this.device,
+        attributes: { ...this.attributes }
+      },
+      events: [...this.events]
+    };
+  }
+  /** Envía (vía sink) el lote acumulado y vacía el buffer. No-op si no hay eventos. */
+  flush(identity) {
+    if (this.events.length === 0) return null;
+    const payload = this.buildPayload(identity);
+    this.sink(payload);
+    this.events = [];
+    return payload;
+  }
+};
+
+// src/analytics/feedback-payload.ts
+function pushKV(list, key, value) {
+  if (value === void 0 || value === null || value === "") return;
+  list.push({ key, value: [String(value)] });
+}
+function buildAnalyticsFeedbackBody(envelope, keys, feedbackSessionId) {
+  const { context } = envelope;
+  const profile = [];
+  pushKV(profile, "external-user-id", envelope.userId);
+  const metadata = [];
+  pushKV(metadata, "deepdots_user_id", envelope.userId);
+  pushKV(metadata, "deepdots_session_id", envelope.sessionId);
+  pushKV(metadata, "deepdots_platform", context.platform);
+  pushKV(metadata, "deepdots_language", context.language);
+  if (context.device) {
+    const d = context.device;
+    pushKV(metadata, "deepdots_device_type", d.device_type);
+    pushKV(metadata, "deepdots_os_version", d.os_version);
+    pushKV(metadata, "deepdots_device_model", d.device_model);
+    pushKV(metadata, "deepdots_app_version", d.app_version);
+    pushKV(metadata, "deepdots_user_agent", d.user_agent);
+    pushKV(metadata, "deepdots_timezone", d.timezone);
+    pushKV(metadata, "deepdots_referrer", d.referrer);
+    pushKV(metadata, "deepdots_viewport_size", d.viewport_size);
+    pushKV(metadata, "deepdots_screen_resolution", d.screen_resolution);
+    pushKV(metadata, "deepdots_pixel_ratio", d.pixel_ratio);
+    pushKV(metadata, "deepdots_entry_type", d.entry_type);
+    pushKV(metadata, "deepdots_page_load_ms", d.page_load_ms);
+    pushKV(metadata, "deepdots_connection_type", d.connection_type);
+    pushKV(metadata, "deepdots_country", d.country);
+    pushKV(metadata, "deepdots_city", d.city);
+  }
+  for (const [k, v] of Object.entries(context.attributes ?? {})) {
+    pushKV(metadata, k, v);
+  }
+  for (const e of envelope.events) {
+    metadata.push({
+      key: e.name,
+      value: [JSON.stringify({ timestamp: e.timestamp, ...e.params ?? {} })]
+    });
+  }
+  return {
+    feedback: {
+      text: "",
+      answers: [],
+      metadata,
+      profile,
+      finished: false
+    },
+    publicKey: keys.publicKey,
+    integration: keys.integration,
+    completed: false,
+    ...feedbackSessionId ? { sessionId: feedbackSessionId } : {}
+  };
+}
+function createFeedbackSink(options) {
+  let feedbackSessionId;
+  return (envelope) => {
+    const body = buildAnalyticsFeedbackBody(envelope, options.keys, feedbackSessionId);
+    const f = options.fetchImpl ?? (typeof fetch !== "undefined" ? fetch : void 0);
+    if (!f) {
+      options.log?.("[DeepdotsAnalytics] no fetch disponible; payload no enviado", body);
+      return;
+    }
+    options.log?.("[DeepdotsAnalytics] POST /sdk/feedback \u2192", body);
+    f(`${options.baseUrl}/sdk/feedback`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }).then(async (res) => {
+      if (res.ok) {
+        try {
+          const data = await res.json();
+          if (data?.sessionId && data.sessionId !== feedbackSessionId) {
+            feedbackSessionId = data.sessionId;
+            options.log?.("[DeepdotsAnalytics] feedbackSessionId cacheado:", feedbackSessionId);
+            options.onSessionId?.(feedbackSessionId);
+          }
+        } catch {
+        }
+      }
+    }).catch((err) => options.log?.("[DeepdotsAnalytics] error enviando feedback", err));
+  };
+}
+
+// src/tracking/navigation-observer.ts
+var UUID_PREFIX = /^[0-9a-f]{8}-[0-9a-f]{4}-/i;
+function normalizeScreen(href) {
+  let pathAndHash;
+  try {
+    const u = new URL(href, "http://deepdots.local");
+    pathAndHash = u.pathname + (u.hash || "");
+  } catch {
+    pathAndHash = href;
+  }
+  pathAndHash = pathAndHash.replace(/\?[^#]*/g, "");
+  const collapsed = pathAndHash.split("/").map((seg) => /^[0-9]+$/.test(seg) || UUID_PREFIX.test(seg) ? ":id" : seg).join("/");
+  return collapsed || "/";
+}
+var NavigationObserver = class {
+  constructor(options = {}) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.currentScreen = null;
+    this.entryAt = 0;
+    this.installed = false;
+    this.domHandlers = [];
+    this.now = options.now ?? (() => Date.now());
+  }
+  onVisit(listener) {
+    this.listeners.add(listener);
+  }
+  /** Fija la pantalla inicial (sin emitir visita; su duración se cierra al salir). */
+  begin(href) {
+    this.currentScreen = normalizeScreen(href);
+    this.entryAt = this.now();
+  }
+  /** Navega a una pantalla nueva: cierra la anterior (emite visita) y abre la nueva. */
+  visit(href) {
+    const next = normalizeScreen(href);
+    if (next === this.currentScreen) return;
+    this.closeCurrent();
+    this.currentScreen = next;
+    this.entryAt = this.now();
+  }
+  /** Cierra la pantalla actual emitiendo su visita (p. ej. al cerrar la app/pestaña). */
+  stop() {
+    this.closeCurrent();
+    this.currentScreen = null;
+  }
+  closeCurrent() {
+    if (this.currentScreen == null) return;
+    const exit = this.now();
+    const visit = {
+      screen: this.currentScreen,
+      entry: this.entryAt,
+      exit,
+      durationSeconds: Math.max(0, Math.round((exit - this.entryAt) / 1e3))
+    };
+    this.listeners.forEach((l) => {
+      try {
+        l(visit);
+      } catch {
+      }
+    });
+  }
+  /** Instala los hooks de History en el navegador y registra la pantalla actual. */
+  install() {
+    if (this.installed || typeof window === "undefined" || typeof history === "undefined") return;
+    this.installed = true;
+    const handle = () => this.visit(window.location.href);
+    const originalPush = history.pushState.bind(history);
+    const originalReplace = history.replaceState.bind(history);
+    history.pushState = (data, unused, url) => {
+      const r = originalPush(data, unused, url);
+      handle();
+      return r;
+    };
+    history.replaceState = (data, unused, url) => {
+      const r = originalReplace(data, unused, url);
+      handle();
+      return r;
+    };
+    window.addEventListener("popstate", handle);
+    window.addEventListener("hashchange", handle);
+    this.domHandlers.push(() => {
+      history.pushState = originalPush;
+      history.replaceState = originalReplace;
+      window.removeEventListener("popstate", handle);
+      window.removeEventListener("hashchange", handle);
+    });
+    this.begin(window.location.href);
+  }
+  uninstall() {
+    this.domHandlers.forEach((off) => off());
+    this.domHandlers = [];
+    this.installed = false;
+  }
+};
+
+// src/analytics/device-info.ts
+function parseDeviceType(ua) {
+  const s = (ua || "").toLowerCase();
+  if (/ipad|tablet|playbook|silk/.test(s) || /android/.test(s) && !/mobile/.test(s)) {
+    return "tablet";
+  }
+  if (/mobi|iphone|ipod|windows phone/.test(s) || /android/.test(s) && /mobile/.test(s)) {
+    return "mobile";
+  }
+  return "desktop";
+}
+function getEntryType() {
+  if (typeof performance === "undefined") return void 0;
+  const entries = performance.getEntriesByType("navigation");
+  if (!entries.length) return void 0;
+  return entries[0].type;
+}
+function getPageLoadMs() {
+  if (typeof performance === "undefined") return void 0;
+  const entries = performance.getEntriesByType("navigation");
+  if (!entries.length) return void 0;
+  const load = entries[0].loadEventEnd;
+  return load > 0 ? Math.round(load) : void 0;
+}
+function getConnectionType() {
+  if (typeof navigator === "undefined") return void 0;
+  return navigator.connection?.effectiveType ?? void 0;
+}
+function collectDeviceInfo(appVersion) {
+  const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
+  return {
+    device_type: parseDeviceType(ua),
+    user_agent: ua || void 0,
+    app_version: appVersion,
+    timezone: typeof Intl !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : void 0,
+    referrer: typeof document !== "undefined" && document.referrer ? document.referrer : void 0,
+    viewport_size: typeof window !== "undefined" ? `${window.innerWidth}x${window.innerHeight}` : void 0,
+    screen_resolution: typeof screen !== "undefined" ? `${screen.width}x${screen.height}` : void 0,
+    pixel_ratio: typeof window !== "undefined" ? window.devicePixelRatio : void 0,
+    entry_type: getEntryType(),
+    page_load_ms: getPageLoadMs(),
+    connection_type: getConnectionType()
+  };
+}
+
+// src/analytics/geo-info.ts
+async function collectGeoInfo(fetchImpl) {
+  const f = fetchImpl ?? (typeof fetch !== "undefined" ? fetch : void 0);
+  if (!f) return null;
+  try {
+    const res = await f("https://ipapi.co/json/");
+    if (!res.ok) return null;
+    const data = await res.json();
+    const country = data.country_code || void 0;
+    const city = data.city || void 0;
+    if (!country && !city) return null;
+    return { country, city };
+  } catch {
+    return null;
+  }
+}
+
+// src/analytics/engagement-tracker.ts
+var EngagementTracker = class {
+  constructor(now = () => Date.now()) {
+    this.activeMs = 0;
+    this.lastResumeAt = null;
+    this.now = now;
+  }
+  /** Reanuda el conteo (pestaña visible / app en foreground). Idempotente. */
+  resume() {
+    if (this.lastResumeAt === null) this.lastResumeAt = this.now();
+  }
+  /** Pausa el conteo (pestaña oculta / app en background), acumulando el tramo activo. */
+  pause() {
+    if (this.lastResumeAt !== null) {
+      this.activeMs += this.now() - this.lastResumeAt;
+      this.lastResumeAt = null;
+    }
+  }
+  /** Devuelve los ms activos acumulados desde la última lectura y reinicia (sin parar el timer). */
+  consume() {
+    if (this.lastResumeAt !== null) {
+      const t = this.now();
+      this.activeMs += t - this.lastResumeAt;
+      this.lastResumeAt = t;
+    }
+    const ms = this.activeMs;
+    this.activeMs = 0;
+    return ms;
+  }
+  isActive() {
+    return this.lastResumeAt !== null;
+  }
+};
+
+// src/contact/contact-manager.ts
+init_tracking_manager();
+function stableSerialize(attrs) {
+  const sorted = {};
+  for (const key of Object.keys(attrs).sort()) {
+    sorted[key] = attrs[key];
+  }
+  return JSON.stringify(sorted);
+}
+var ContactManager = class {
+  constructor(options) {
+    this.storage = options.storage;
+    this.publicKey = options.publicKey;
+    this.userId = options.userId;
+    this.post = options.post;
+  }
+  /**
+   * Envía los atributos si cambiaron respecto a lo último enviado.
+   * @returns `true` si se envió, `false` si no hubo cambios.
+   */
+  async setAttributes(attributes) {
+    const serialized = stableSerialize(attributes);
+    const last = this.storage.getItem(STORAGE_KEYS.contactAttributes);
+    if (last === serialized) return false;
+    await this.post({
+      publicKey: this.publicKey,
+      userId: this.userId,
+      userAttributes: attributes
+    });
+    this.storage.setItem(STORAGE_KEYS.contactAttributes, serialized);
+    return true;
+  }
+};
+
 // src/core/deepdots-popups.ts
 var EXIT_QUEUE_STORAGE_KEY = "__deepdots_exit_popup_queue__";
 var DAY_IN_MS = 24 * 60 * 60 * 1e3;
+var ANALYTICS_MAX_BATCH_SIZE = 20;
+var ANALYTICS_FLUSH_INTERVAL_MS = 3e4;
 var DeepdotsPopups = class {
   constructor() {
     this.config = null;
@@ -3642,6 +4279,22 @@ var DeepdotsPopups = class {
     this.deferredExitTimers = [];
     this.baseUrl = "";
     this.env = "production";
+    /** Identidad + sesión (Fase 1 tracking). Null hasta init(). */
+    this.tracking = null;
+    /** Capa de analytics (canal separado del feedback). Null hasta init(). */
+    this.analytics = null;
+    /** feedbackSessionId cacheado del canal de analytics (devuelto por POST /sdk/feedback). */
+    this.analyticsFeedbackSessionId = void 0;
+    /** Timer del flush periódico de analytics (cada ANALYTICS_FLUSH_INTERVAL_MS). */
+    this.analyticsFlushTimer = void 0;
+    /** Observador de navegación (Fase 2): emite page_view por el canal de analytics. */
+    this.navObserver = null;
+    /** Tiempo activo (engagement time, #8). */
+    this.engagement = null;
+    /** Atributos internos del usuario identificado → POST /sdk/popups/contact. Null si no hay userId. */
+    this.contact = null;
+    /** Marca si ya se inició la navegación manual (setScreen) — para RN sin History API. */
+    this.navStarted = false;
   }
   /** Initialize the SDK with configuration */
   init(config) {
@@ -3654,33 +4307,207 @@ var DeepdotsPopups = class {
     this.env = config.nodeEnv || "production";
     this.config = {
       apiKey: config.apiKey || void 0,
-      mode: config.mode || "client",
       debug: config.debug || false,
-      popups: config.popups || [],
       userId: config.userId || void 0
     };
+    const storage = config.storage ?? createDefaultStorage();
+    this.tracking = new TrackingManager({
+      storage,
+      clientUserId: this.config.userId,
+      enabled: config.trackingEnabled ?? true
+    });
+    if (this.config.userId) {
+      const userId = this.config.userId;
+      const publicKey = this.config.apiKey ?? "";
+      this.contact = new ContactManager({
+        storage,
+        publicKey,
+        userId,
+        post: (body) => this.postContact(body)
+      });
+      if (config.contactAttributes) {
+        void this.setContactAttributes(config.contactAttributes);
+      }
+    }
+    this.log("tracking \xB7 user_id:", this.tracking.getUserId(), "\xB7 new_user:", this.tracking.isNewUser(), "\xB7 enabled:", this.tracking.isTrackingEnabled());
+    const analyticsSink = config.analytics ? createFeedbackSink({
+      baseUrl: this.baseUrl,
+      keys: config.analytics,
+      log: (...a) => this.log(...a),
+      onSessionId: (id) => {
+        this.analyticsFeedbackSessionId = id;
+      }
+    }) : void 0;
+    this.analytics = new AnalyticsManager({
+      sink: analyticsSink,
+      publicKey: config.analytics?.publicKey ?? this.config.apiKey,
+      language: typeof navigator !== "undefined" ? navigator.language : void 0,
+      platform: config.platform ?? "web",
+      device: config.device ?? collectDeviceInfo(config.appVersion),
+      maxBatchSize: ANALYTICS_MAX_BATCH_SIZE,
+      onFlushNeeded: () => this.flushAnalytics()
+    });
+    collectGeoInfo().then((geo) => {
+      if (geo) this.analytics?.updateDevice(geo);
+    }).catch(() => {
+    });
+    this.navObserver = new NavigationObserver();
+    this.navObserver.onVisit((v) => this.track("page_view", { screen: v.screen, duration_seconds: v.durationSeconds }));
+    this.navObserver.install();
+    this.engagement = new EngagementTracker();
+    this.engagement.resume();
+    this.setupAnalyticsFlush();
     this.initialized = true;
     this.log("SDK initialized", this.config);
     if (this.renderer.init) this.renderer.init();
     this.setupPopupContainer();
-    if (this.config.mode === "client") {
-      this.popupDefinitions = this.validatePopupDefinitions(this.config.popups || []);
+    this.fetchPopupsFromServer().then((defs) => {
+      this.popupDefinitions = this.validatePopupDefinitions(defs);
       this.popupsLoaded = true;
+      this.log("Popups loaded from API", this.popupDefinitions);
       this.configureTriggersFromDefinitions();
       this.processDeferredExitQueue();
+      if (this.pendingAutoLaunch) {
+        this.startTriggers();
+      }
+    });
+  }
+  /** User id actual (generado por el SDK o provisto por el cliente). Null si tracking off. */
+  getUserId() {
+    return this.tracking?.getUserId() ?? null;
+  }
+  /** Session id de navegación actual. Null si tracking off. */
+  getSessionId() {
+    return this.tracking?.getSessionId() ?? null;
+  }
+  /** Activa/desactiva el tracking (identidad + sesión + analytics). Kill-switch del contrato §7bis. */
+  setTrackingEnabled(enabled) {
+    this.tracking?.setTrackingEnabled(enabled);
+    this.log("tracking \xB7 setTrackingEnabled:", enabled, "\xB7 session_id:", this.tracking?.getSessionId() ?? null);
+  }
+  // ───────── Analytics (canal separado del feedback, vinculado por user_id) ─────────
+  /** Registra un evento de analítica (modelo GA: nombre + params). No-op si tracking off. */
+  track(name, params) {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.analytics?.track(name, params);
+    this.log("analytics \xB7 track:", name, params ?? {});
+  }
+  /** User attributes para breakdowns (registration_status, pass_type, sector, pass_status…). */
+  setUserAttributes(attributes) {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.analytics?.setUserAttributes(attributes);
+  }
+  /**
+   * Info interna del usuario que solo conoce el host (idioma, edad, plan…), persistida en el
+   * Contact del backend para segmentación/targeting de popups. Identificada por el `userId` del
+   * init. Solo envía si los atributos cambiaron (diff en storage). No-op si tracking off o sin userId.
+   * @returns `true` si se envió al backend, `false` si no hubo cambios o está deshabilitado.
+   */
+  async setContactAttributes(attributes) {
+    if (!this.tracking?.isTrackingEnabled()) return false;
+    if (!this.contact) return false;
+    return this.contact.setAttributes(attributes);
+  }
+  /** Marca el inicio de un mini-service; etiqueta los eventos siguientes. No-op si tracking off. */
+  enterMiniService(name, entryPointType) {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.analytics?.enterMiniService(name, entryPointType);
+    this.log("analytics \xB7 enterMiniService:", name, entryPointType ?? "");
+  }
+  /** Cierra el mini-service activo (emite `mini_service_exit` con duración, #27). No-op si tracking off. */
+  exitMiniService() {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.analytics?.exitMiniService();
+    this.log("analytics \xB7 exitMiniService");
+  }
+  /** Findability (#31/#35): registra una búsqueda. `has_results` se deriva de `resultsCount`. */
+  trackSearch(query, resultsCount, params) {
+    this.track("search", { query, results_count: resultsCount, has_results: resultsCount > 0, ...params ?? {} });
+  }
+  /** Findability friction (#34/#35): señal de fricción con su `friction_topic`. */
+  trackFindabilityFriction(frictionTopic, params) {
+    this.track("findability_friction", { friction_topic: frictionTopic, ...params ?? {} });
+  }
+  /** Funnel: un paso del embudo, correlacionado por `taskId`. El backend reconstruye conversión/drop-off/tiempo. */
+  trackFunnelStep(funnel, step, taskId, params) {
+    this.track("funnel_step", { funnel, step, task_id: taskId, ...params ?? {} });
+  }
+  /**
+   * Navegación MANUAL (entornos sin History API, p. ej. React Native con React Navigation).
+   * El host la llama en cada cambio de pantalla; emite `page_view` al salir de la anterior.
+   */
+  setScreen(name) {
+    if (!this.navObserver) return;
+    if (!this.navStarted) {
+      this.navObserver.begin(name);
+      this.navStarted = true;
     } else {
-      this.fetchPopupsFromServer().then((defs) => {
-        this.popupDefinitions = this.validatePopupDefinitions(defs);
-        this.popupsLoaded = true;
-        this.log("Popups loaded from server (fake)", this.popupDefinitions);
-        this.configureTriggersFromDefinitions();
-        this.processDeferredExitQueue();
-        if (this.pendingAutoLaunch) {
-          this.startTriggers();
-        }
-      });
+      this.navObserver.visit(name);
     }
   }
+  /** App a foreground (RN: AppState 'active'): reanuda el engagement time. */
+  onForeground() {
+    this.engagement?.resume();
+  }
+  /**
+   * App a background (RN: AppState 'background'): cierra pantalla actual (page_view),
+   * mini-service (mini_service_exit), emite engagement y hace flush del lote.
+   */
+  onBackground() {
+    this.navObserver?.stop();
+    this.navStarted = false;
+    this.exitMiniService();
+    this.flushEngagement();
+    this.engagement?.pause();
+    this.flushAnalytics();
+  }
+  /** Payload que se ENVIARÍA al endpoint de analytics (no envía ni vacía el buffer). */
+  previewAnalytics() {
+    return this.analytics?.buildPayload(this.analyticsIdentity()) ?? {
+      userId: null,
+      sessionId: null,
+      context: { platform: "web", attributes: {} },
+      events: []
+    };
+  }
+  /** Envía (hoy dry-run → console.log) el lote acumulado de analytics y vacía el buffer. */
+  flushAnalytics() {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.analytics?.flush(this.analyticsIdentity());
+  }
+  /** Emite un evento `user_engagement` con el tiempo activo acumulado (#8). */
+  flushEngagement() {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    const ms = this.engagement?.consume() ?? 0;
+    if (ms > 0) this.track("user_engagement", { engagement_time_msec: ms });
+  }
+  analyticsIdentity() {
+    return {
+      userId: this.tracking?.getUserId() ?? null,
+      sessionId: this.tracking?.getSessionId() ?? null
+    };
+  }
+  /** Flush automático al ocultar/cerrar la página (no perder el lote pendiente). */
+  setupAnalyticsFlush() {
+    if (typeof document === "undefined" || typeof window === "undefined") return;
+    this.analyticsFlushTimer = setInterval(() => this.flushAnalytics(), ANALYTICS_FLUSH_INTERVAL_MS);
+    window.addEventListener("pagehide", () => {
+      clearInterval(this.analyticsFlushTimer);
+      this.navObserver?.stop();
+      this.exitMiniService();
+      this.flushEngagement();
+      this.flushAnalytics();
+    });
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") {
+        this.flushEngagement();
+        this.engagement?.pause();
+        this.flushAnalytics();
+      } else if (document.visibilityState === "visible") {
+        this.engagement?.resume();
+      }
+    });
+  }
   /** Enable auto-launch functionality with configured triggers */
   autoLaunch() {
     if (!this.initialized) {
@@ -3698,35 +4525,6 @@ var DeepdotsPopups = class {
     this.log("Auto-launch enabled");
     this.triggers.forEach((trigger) => setupTrigger(this, trigger));
   }
-  /** Show a popup immediately (supports legacy ShowOptions and new PopupDefinition) */
-  show(options) {
-    if (!this.initialized) {
-      throw new Error("SDK not initialized. Call init() first.");
-    }
-    const isDefinition = options.id !== void 0;
-    if (isDefinition) {
-      const def = options;
-      this.log("Showing popup (definition)", def);
-      this.surveyToPopupId.set(def.surveyId, def.id);
-      this.lastShown.set(def.id, Date.now());
-      this.renderPopup(def.surveyId, def.productId, def.actions, def.style);
-      this.emitEvent("popup_shown", def.surveyId, { popupId: def.id });
-    } else {
-      const opt = options;
-      this.log("Showing popup (legacy options)", opt);
-      this.renderPopup(opt.surveyId, opt.productId, void 0);
-      this.emitEvent("popup_shown", opt.surveyId);
-    }
-  }
-  /** Mostrar popup por id de definición (usa surveyId interno) */
-  showByPopupId(popupId) {
-    const def = this.popupDefinitions.find((popup) => popup.id === popupId);
-    if (!def) {
-      this.log("Popup definition not found", popupId);
-      return;
-    }
-    this.show(def);
-  }
   /** Configure triggers for auto-launching popups (manual) */
   configureTriggers(triggers) {
     if (!this.initialized) {
@@ -3795,7 +4593,11 @@ var DeepdotsPopups = class {
     this.showDefinition(matched);
   }
   showDefinition(def) {
-    this.show(def);
+    this.log("Showing popup (definition)", def);
+    this.surveyToPopupId.set(def.surveyId, def.id);
+    this.lastShown.set(def.id, Date.now());
+    this.renderPopup(def.surveyId, def.productId, def.actions, def.style);
+    this.emitEvent("popup_shown", def.surveyId, { popupId: def.id });
   }
   shouldShow(def, pathUrl, skipPathCheck = false) {
     if (!skipPathCheck && !this.matchesSegmentsPath(def, pathUrl)) {
@@ -4039,6 +4841,26 @@ var DeepdotsPopups = class {
       return [];
     }
   }
+  /** Envía los atributos de contact a la API (`POST /sdk/popups/contact`). */
+  async postContact(body) {
+    const baseUrl = this.baseUrl;
+    if (!baseUrl) return;
+    const endpoint = `${baseUrl}/sdk/popups/contact`;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        this.log("Failed to post contact", response.status, response.statusText);
+        return;
+      }
+      this.log("contact \xB7 sent attributes for user:", body.userId);
+    } catch (error) {
+      this.log("Error posting contact", error);
+    }
+  }
   /** Notifica eventos de popup a la API */
   async postPopupEvent(status, popupId, userId) {
     const apiKey = this.config?.apiKey;
@@ -4060,6 +4882,15 @@ var DeepdotsPopups = class {
       });
       if (!response.ok) {
         this.log("Failed to post popup event", response.status, response.statusText);
+        return;
+      }
+      try {
+        const data = await response.json();
+        if (data && typeof data.sessionId === "string") {
+          this.tracking?.setSessionId(data.sessionId);
+          this.log("tracking \xB7 session_id from backend:", data.sessionId);
+        }
+      } catch {
       }
     } catch (error) {
       this.log("Error posting popup event", error);
@@ -4102,7 +4933,11 @@ var DeepdotsPopups = class {
   }
   /** Render the popup UI */
   renderPopup(surveyId, productId, actions, style) {
-    const userId = this.config?.userId;
+    const userId = this.tracking?.getUserId() ?? this.config?.userId;
+    const sessionId = this.tracking?.getSessionId() ?? void 0;
+    const miniService = this.analytics?.getMiniService() ?? void 0;
+    const analyticsFeedbackSessionId = this.analyticsFeedbackSessionId;
+    this.log("tracking \xB7 survey identity \u2192", { userId: userId ?? null, sessionId: sessionId ?? null, miniService: miniService ?? null, analyticsFeedbackSessionId: analyticsFeedbackSessionId ?? null });
     if (this.renderer) {
       this.renderer.show(
         surveyId,
@@ -4112,22 +4947,31 @@ var DeepdotsPopups = class {
         () => this.hidePopup(),
         this.env,
         userId,
-        style
+        style,
+        sessionId,
+        miniService,
+        analyticsFeedbackSessionId
       );
       return;
     }
     if (!this.popupContainer) return;
-    renderPopup(
-      this.popupContainer,
-      surveyId,
-      productId,
-      actions,
-      (type, id, payload) => this.emitEvent(type, id, payload),
-      () => this.hidePopup(),
-      this.env,
-      userId,
-      style
-    );
+    const container = this.popupContainer;
+    void Promise.resolve().then(() => (init_renderPopup(), renderPopup_exports)).then(({ renderPopup: renderPopup2 }) => {
+      renderPopup2(
+        container,
+        surveyId,
+        productId,
+        actions,
+        (type, id, payload) => this.emitEvent(type, id, payload),
+        () => this.hidePopup(),
+        this.env,
+        userId,
+        style,
+        sessionId,
+        miniService,
+        analyticsFeedbackSessionId
+      );
+    });
   }
   /** Hide the popup */
   hidePopup() {
@@ -4157,7 +5001,7 @@ var DeepdotsPopups = class {
       if (popupId) {
         const userIdFromData = data?.userId;
         const status = type === "popup_shown" ? "SHOWED" /* SHOWED */ : type === "survey_completed" ? "COMPLETED" /* COMPLETED */ : "PARTIAL" /* PARTIAL */;
-        void this.postPopupEvent(status, popupId, userIdFromData || this.config?.userId);
+        void this.postPopupEvent(status, popupId, userIdFromData || this.tracking?.getUserId() || this.config?.userId);
       } else {
         this.debug("No popupId available to post event", { type, surveyId });
       }
@@ -4293,4 +5137,41 @@ var DeepdotsPopups = class {
     return defs.map((def) => this.normalizePopupDefinition(def)).filter((def) => !!def && this.isPopupDefinition(def));
   }
 };
+
+// src/index.ts
+init_tracking_manager();
+
+// src/react-native/setup.ts
+function mmkvStorage(mmkv) {
+  return {
+    getItem: (k) => mmkv.getString(k) ?? null,
+    setItem: (k, v) => mmkv.set(k, v),
+    removeItem: (k) => mmkv.delete(k)
+  };
+}
+function collectRnDevice(d) {
+  return {
+    device_type: d.isTablet?.() ? "tablet" : "mobile",
+    os_version: d.getSystemVersion?.(),
+    device_model: d.getDeviceId?.(),
+    app_version: d.getVersion?.()
+  };
+}
+function setupReactNative(sdk, config, deps = {}) {
+  if (deps.renderer) sdk.setRenderer(deps.renderer);
+  const storage = deps.mmkv ? mmkvStorage(deps.mmkv) : config.storage;
+  const device = deps.deviceInfo ? collectRnDevice(deps.deviceInfo) : config.device;
+  const platform = deps.platform ?? config.platform;
+  sdk.init({ ...config, storage, device, platform });
+  let subscription;
+  if (deps.appState?.addEventListener) {
+    subscription = deps.appState.addEventListener("change", (state) => {
+      if (state === "active") sdk.onForeground();
+      else sdk.onBackground();
+    });
+  }
+  return () => {
+    if (subscription && typeof subscription.remove === "function") subscription.remove();
+  };
+}
 //# sourceMappingURL=index.js.map