@magicfeedback/popup-sdk 1.1.1 → 1.1.3

package/dist/react-native.mjs

@@ -4,7 +4,7 @@ import {
   __require,
   buildSurveyIdentity,
   createDefaultStorage
-} from "./chunk-M6PEFLLQ.mjs";
+} from "./chunk-IOAZQPZE.mjs";
 
 // src/react-native/index.tsx
 import { createContext, useContext, useEffect, useRef, useState } from "react";
@@ -258,12 +258,12 @@ var ReactNativePopupRenderer = class {
   }
   init() {
   }
-  show(surveyId, productId, _actions, emit, onClose, env = "production", userId, _style, sessionId, miniService) {
+  show(surveyId, productId, _actions, emit, onClose, env = "production", userId, _style, sessionId, miniService, analyticsFeedbackSessionId) {
     this.emitFn = emit;
     this.onCloseFn = onClose;
     this.currentSurveyId = surveyId;
     this.partialEmitted = false;
-    const { profile, metadata } = buildSurveyIdentity(userId ?? null, sessionId ?? null, miniService ?? null);
+    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 });
@@ -354,14 +354,14 @@ var BrowserPopupRenderer = class {
       document.body.appendChild(this.container);
     }
   }
-  show(surveyId, productId, actions, emit, onClose, env = "production", userId, style, sessionId, miniService) {
+  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;
     const container = this.container;
-    void import("./renderPopup-7GGKR5BY.mjs").then(({ renderPopup }) => {
-      renderPopup(container, surveyId, productId, actions, emit, onClose, env, userId, style, sessionId, miniService);
+    void import("./renderPopup-KBDWWSUU.mjs").then(({ renderPopup }) => {
+      renderPopup(container, surveyId, productId, actions, emit, onClose, env, userId, style, sessionId, miniService, analyticsFeedbackSessionId);
     });
   }
   hide() {
@@ -392,14 +392,20 @@ var AnalyticsManager = class {
   constructor(options = {}) {
     this.events = [];
     this.attributes = {};
-    this.miniService = null;
-    this.miniServiceEnteredAt = 0;
+    /** Mini-services activos: nombre → timestamp de entrada. El orden de inserción marca el "más reciente". */
+    this.activeMiniServices = /* @__PURE__ */ new Map();
     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) {
@@ -408,24 +414,38 @@ var AnalyticsManager = class {
       this.attributes[k] = String(v);
     }
   }
-  /** Marca el inicio de un mini-service; etiqueta los eventos siguientes con `mini_service`. */
+  /**
+   * Marca el inicio de un mini-service; etiqueta los eventos siguientes con `mini_service`.
+   * Admite varios activos a la vez (concurrencia); el "actual" para etiquetar es el más reciente.
+   * Reentrar con un nombre ya activo refresca su orden y su tiempo de entrada.
+   */
   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 });
+    this.activeMiniServices.delete(name);
+    this.activeMiniServices.set(name, this.now());
+    this.track("deepdots_mini_service_enter", { entry_point_type: entryPointType ?? null });
+  }
+  /**
+   * Cierra el mini-service `name` emitiendo `mini_service_exit` con su duración (#27).
+   * No-op si ese nombre no está activo. Cierre coherente con concurrencia.
+   */
+  exitMiniService(name) {
+    const enteredAt = this.activeMiniServices.get(name);
+    if (enteredAt === void 0) return;
+    const durationSeconds = Math.max(0, Math.round((this.now() - enteredAt) / 1e3));
+    this.activeMiniServices.delete(name);
+    this.track("deepdots_mini_service_exit", { mini_service: name, duration_seconds: durationSeconds });
+  }
+  /** Cierra TODOS los mini-services activos (orden LIFO). Para el cierre por lifecycle (background/cierre). */
+  exitAllMiniServices() {
+    for (const name of Array.from(this.activeMiniServices.keys()).reverse()) {
+      this.exitMiniService(name);
+    }
   }
   /** Registra un evento de analítica (modelo GA: nombre + params). */
   track(name, params) {
+    const current = this.getMiniService();
     const merged = {
-      ...this.miniService ? { mini_service: this.miniService } : {},
+      ...current ? { mini_service: current } : {},
       ...params ?? {}
     };
     this.events.push({
@@ -433,10 +453,15 @@ var AnalyticsManager = class {
       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). */
+  /** Mini-service actual (el más reciente aún activo) para etiquetar eventos + metadata del survey (#33). */
   getMiniService() {
-    return this.miniService;
+    let last = null;
+    for (const name of this.activeMiniServices.keys()) last = name;
+    return last;
   }
   /** Nº de eventos pendientes de flush. */
   pending() {
@@ -470,44 +495,55 @@ var AnalyticsManager = class {
 // src/analytics/feedback-payload.ts
 function pushKV(list, key, value) {
   if (value === void 0 || value === null || value === "") return;
-  list.push({ key, value: String(value) });
+  list.push({ key, value: [String(value)] });
 }
 function buildAnalyticsFeedbackBody(envelope, keys, feedbackSessionId) {
   const { context } = envelope;
-  const metrics = envelope.events.map((e) => ({
-    key: e.name,
-    value: JSON.stringify({ timestamp: e.timestamp, ...e.params ?? {} })
-  }));
   const profile = [];
   pushKV(profile, "external-user-id", envelope.userId);
   const metadata = [];
-  pushKV(metadata, "user_id", envelope.userId);
-  pushKV(metadata, "session_id", envelope.sessionId);
-  pushKV(metadata, "platform", context.platform);
-  pushKV(metadata, "language", context.language);
+  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) {
-    pushKV(metadata, "device_type", context.device.device_type);
-    pushKV(metadata, "os_version", context.device.os_version);
-    pushKV(metadata, "device_model", context.device.device_model);
-    pushKV(metadata, "app_version", context.device.app_version);
-    pushKV(metadata, "user_agent", context.device.user_agent);
+    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,
-      metrics,
       profile,
       finished: false
     },
     publicKey: keys.publicKey,
     integration: keys.integration,
     completed: false,
-    // finished: false,
     ...feedbackSessionId ? { sessionId: feedbackSessionId } : {}
   };
 }
@@ -532,6 +568,7 @@ function createFeedbackSink(options) {
           if (data?.sessionId && data.sessionId !== feedbackSessionId) {
             feedbackSessionId = data.sessionId;
             options.log?.("[DeepdotsAnalytics] feedbackSessionId cacheado:", feedbackSessionId);
+            options.onSessionId?.(feedbackSessionId);
           }
         } catch {
         }
@@ -645,15 +682,57 @@ function parseDeviceType(ua) {
   }
   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
+    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()) {
@@ -721,9 +800,137 @@ var ContactManager = class {
   }
 };
 
+// src/analytics/crash-reporter.ts
+var STACK_MAX = 8e3;
+var QUEUE_KEY = "deepdots.crash.queue";
+var MAX_QUEUED = 20;
+function crashRecordToParams(r) {
+  const params = {
+    crashed_at: r.crashedAt,
+    crash_type: r.crashType,
+    message: r.message,
+    stack: r.stack,
+    fatal: r.fatal,
+    handled: r.handled,
+    severity: r.severity
+  };
+  if (r.sessionId) params.crashed_session_id = r.sessionId;
+  if (r.appVersion) params.crashed_app_version = r.appVersion;
+  if (r.osVersion) params.crashed_os_version = r.osVersion;
+  if (r.deviceModel) params.crashed_device_model = r.deviceModel;
+  if (r.context) {
+    for (const [k, v] of Object.entries(r.context)) params[`ctx_${k}`] = v;
+  }
+  return params;
+}
+var CrashReporter = class {
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? (() => Date.now());
+  }
+  isEnabled() {
+    return this.options.enabled ? this.options.enabled() : true;
+  }
+  /** Construye un CrashRecord capturando contexto en el momento del crash. */
+  buildRecord(error, severity, handled, fatal, context) {
+    const err = error;
+    const isErr = error instanceof Error;
+    const dev = this.options.device();
+    const ctx = context ? Object.fromEntries(Object.entries(context).map(([k, v]) => [k, String(v)])) : void 0;
+    return {
+      crashedAt: this.now(),
+      crashType: isErr && err.name || "Error",
+      message: isErr ? String(err.message ?? "") : String(error),
+      stack: (isErr && typeof err.stack === "string" ? err.stack : "").slice(0, STACK_MAX),
+      fatal,
+      handled,
+      severity,
+      sessionId: this.options.sessionId(),
+      appVersion: dev.appVersion,
+      osVersion: dev.osVersion,
+      deviceModel: dev.deviceModel,
+      context: ctx
+    };
+  }
+  /** API pública del host: reporta un error (app viva) → emite el evento ya. */
+  reportError(error, options = {}) {
+    if (!this.isEnabled()) return;
+    const severity = options.severity ?? "error";
+    const handled = options.handled ?? true;
+    const fatal = severity === "fatal";
+    const record = this.buildRecord(error, severity, handled, fatal, options.context);
+    this.options.emit(crashRecordToParams(record));
+  }
+  /** Captura un error no manejado (fatal) → persiste a disco para replay en el siguiente arranque. */
+  captureUnhandled(error) {
+    this.persist(this.buildRecord(error, "fatal", false, true));
+  }
+  /** Persiste un crash no capturado a disco para reenviarlo en el siguiente arranque. */
+  persist(record) {
+    let queue = [];
+    try {
+      const raw = this.options.storage.getItem(QUEUE_KEY);
+      if (raw) queue = JSON.parse(raw);
+      if (!Array.isArray(queue)) queue = [];
+    } catch {
+      queue = [];
+    }
+    queue.push(record);
+    if (queue.length > MAX_QUEUED) queue = queue.slice(queue.length - MAX_QUEUED);
+    try {
+      this.options.storage.setItem(QUEUE_KEY, JSON.stringify(queue));
+    } catch {
+    }
+  }
+  /** Lee y vacía la cola de crashes pendientes (llamado en init para el replay). */
+  drainPendingCrashes() {
+    let queue = [];
+    try {
+      const raw = this.options.storage.getItem(QUEUE_KEY);
+      if (raw) queue = JSON.parse(raw);
+      if (!Array.isArray(queue)) queue = [];
+    } catch {
+      queue = [];
+    }
+    if (queue.length) {
+      try {
+        this.options.storage.removeItem(QUEUE_KEY);
+      } catch {
+      }
+    }
+    return queue;
+  }
+  /** Instala los handlers globales de errores no capturados (no-op sin `window`). */
+  install() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("error", (e) => {
+      if (!this.isEnabled()) return;
+      this.captureUnhandled(e.error ?? e.message ?? "error");
+    });
+    window.addEventListener("unhandledrejection", (e) => {
+      if (!this.isEnabled()) return;
+      this.captureUnhandled(e.reason ?? "unhandledrejection");
+    });
+  }
+  /** Engancha `global.ErrorUtils` de RN (no hay `window`): persiste y encadena al handler previo. */
+  installReactNative(errorUtils) {
+    const previous = errorUtils.getGlobalHandler?.();
+    errorUtils.setGlobalHandler((error, isFatal) => {
+      if (this.isEnabled()) this.captureUnhandled(error);
+      previous?.(error, isFatal);
+    });
+  }
+  /** @internal Test seam: ejercita el camino de persistencia (window handlers no son testeables en vitest). */
+  _persistForTest(error) {
+    this.captureUnhandled(error);
+  }
+};
+
 // 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;
@@ -749,6 +956,12 @@ var DeepdotsPopups = class {
     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;
+    /** Crash & error reporting (#14–17). Null hasta init(). */
+    this.crashReporter = null;
     /** Observador de navegación (Fase 2): emite page_view por el canal de analytics. */
     this.navObserver = null;
     /** Tiempo activo (engagement time, #8). */
@@ -795,21 +1008,49 @@ var DeepdotsPopups = class {
     const analyticsSink = config.analytics ? createFeedbackSink({
       baseUrl: this.baseUrl,
       keys: config.analytics,
-      log: (...a) => this.log(...a)
+      log: (...a) => this.log(...a),
+      onSessionId: (id) => {
+        this.analyticsFeedbackSessionId = id;
+      }
     }) : void 0;
+    const device = config.device ?? collectDeviceInfo(config.appVersion);
     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)
+      device,
+      maxBatchSize: ANALYTICS_MAX_BATCH_SIZE,
+      onFlushNeeded: () => this.flushAnalytics()
+    });
+    this.crashReporter = new CrashReporter({
+      storage,
+      emit: (params) => this.track("deepdots_app_crash", params),
+      device: () => ({ appVersion: device.app_version, osVersion: device.os_version, deviceModel: device.device_model }),
+      sessionId: () => this.tracking?.getSessionId() ?? null,
+      now: () => Date.now(),
+      enabled: () => this.tracking?.isTrackingEnabled() ?? false
+    });
+    if (this.tracking?.isTrackingEnabled()) {
+      this.crashReporter.install();
+    }
+    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.onVisit((v) => this.track("deepdots_page_view", { screen: v.screen, duration_seconds: v.durationSeconds }));
     this.navObserver.install();
     this.engagement = new EngagementTracker();
     this.engagement.resume();
     this.setupAnalyticsFlush();
+    this.track("deepdots_session_start", {});
+    const pendingCrashes = this.crashReporter.drainPendingCrashes();
+    if (this.tracking?.isTrackingEnabled()) {
+      for (const rec of pendingCrashes) {
+        this.track("deepdots_app_crash", crashRecordToParams(rec));
+      }
+    }
     this.initialized = true;
     this.log("SDK initialized", this.config);
     if (this.renderer.init) this.renderer.init();
@@ -850,6 +1091,16 @@ var DeepdotsPopups = class {
     if (!this.tracking?.isTrackingEnabled()) return;
     this.analytics?.setUserAttributes(attributes);
   }
+  /** Reporta un error del host (manejado o no) → evento `deepdots_app_crash`. No-op si tracking off. */
+  reportError(error, options) {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.crashReporter?.reportError(error, options);
+  }
+  /** Engancha `global.ErrorUtils` de RN para capturar errores JS no manejados. No-op si tracking off. */
+  installReactNativeCrashHandler(errorUtils) {
+    if (!this.tracking?.isTrackingEnabled()) return;
+    this.crashReporter?.installReactNative(errorUtils);
+  }
   /**
    * 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
@@ -867,23 +1118,23 @@ var DeepdotsPopups = class {
     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() {
+  /** Cierra el mini-service `name` (emite `mini_service_exit` con duración, #27). No-op si tracking off o si ese no está activo. */
+  exitMiniService(name) {
     if (!this.tracking?.isTrackingEnabled()) return;
-    this.analytics?.exitMiniService();
-    this.log("analytics \xB7 exitMiniService");
+    this.analytics?.exitMiniService(name);
+    this.log("analytics \xB7 exitMiniService:", name);
   }
   /** 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 ?? {} });
+    this.track("deepdots_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 ?? {} });
+    this.track("deepdots_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 ?? {} });
+    this.track("deepdots_funnel_step", { funnel, step, task_id: taskId, ...params ?? {} });
   }
   /**
    * Navegación MANUAL (entornos sin History API, p. ej. React Native con React Navigation).
@@ -909,7 +1160,7 @@ var DeepdotsPopups = class {
   onBackground() {
     this.navObserver?.stop();
     this.navStarted = false;
-    this.exitMiniService();
+    if (this.tracking?.isTrackingEnabled()) this.analytics?.exitAllMiniServices();
     this.flushEngagement();
     this.engagement?.pause();
     this.flushAnalytics();
@@ -932,7 +1183,7 @@ var DeepdotsPopups = class {
   flushEngagement() {
     if (!this.tracking?.isTrackingEnabled()) return;
     const ms = this.engagement?.consume() ?? 0;
-    if (ms > 0) this.track("user_engagement", { engagement_time_msec: ms });
+    if (ms > 0) this.track("deepdots_user_engagement", { engagement_time_msec: ms });
   }
   analyticsIdentity() {
     return {
@@ -943,9 +1194,11 @@ var DeepdotsPopups = class {
   /** 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();
+      if (this.tracking?.isTrackingEnabled()) this.analytics?.exitAllMiniServices();
       this.flushEngagement();
       this.flushAnalytics();
     });
@@ -1387,7 +1640,8 @@ var DeepdotsPopups = class {
     const userId = this.tracking?.getUserId() ?? this.config?.userId;
     const sessionId = this.tracking?.getSessionId() ?? void 0;
     const miniService = this.analytics?.getMiniService() ?? void 0;
-    this.log("tracking \xB7 survey identity \u2192", { userId: userId ?? null, sessionId: sessionId ?? null, miniService: miniService ?? null });
+    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,
@@ -1399,13 +1653,14 @@ var DeepdotsPopups = class {
         userId,
         style,
         sessionId,
-        miniService
+        miniService,
+        analyticsFeedbackSessionId
       );
       return;
     }
     if (!this.popupContainer) return;
     const container = this.popupContainer;
-    void import("./renderPopup-7GGKR5BY.mjs").then(({ renderPopup }) => {
+    void import("./renderPopup-KBDWWSUU.mjs").then(({ renderPopup }) => {
       renderPopup(
         container,
         surveyId,
@@ -1417,7 +1672,8 @@ var DeepdotsPopups = class {
         userId,
         style,
         sessionId,
-        miniService
+        miniService,
+        analyticsFeedbackSessionId
       );
     });
   }
@@ -1608,6 +1864,10 @@ function setupReactNative(sdk2, config, deps = {}) {
   const device = deps.deviceInfo ? collectRnDevice(deps.deviceInfo) : config.device;
   const platform = deps.platform ?? config.platform;
   sdk2.init({ ...config, storage, device, platform });
+  const errorUtils = deps.errorUtils ?? globalThis.ErrorUtils;
+  if (errorUtils && typeof errorUtils.setGlobalHandler === "function") {
+    sdk2.installReactNativeCrashHandler(errorUtils);
+  }
   let subscription;
   if (deps.appState?.addEventListener) {
     subscription = deps.appState.addEventListener("change", (state) => {