@reservamos/browser-analytics 1.1.8-alpha.0 → 1.1.8-alpha.2

package/dist/browser-analytics.esm.js

@@ -4173,7 +4173,8 @@ function r$3({ apiName: r2, defaultApiVersion: i }) {
       method: "POST",
       body: JSON.stringify(p3),
       headers: _2,
-      ...(f3 == null ? void 0 : f3.signal) && { signal: f3.signal }
+      ...(f3 == null ? void 0 : f3.signal) && { signal: f3.signal },
+      ...(f3 == null ? void 0 : f3.keepalive) !== void 0 && { keepalive: f3.keepalive }
     });
     return f3 ? y2 : await y2.json();
   }
@@ -4269,7 +4270,8 @@ async function a$3({ requestId: a2, visitorId: o2, distinctId: s2, purchaseToken
       responseType: "response",
       apiPrefix: "api",
       omitHeaders: ["Origin"],
-      signal: u2.signal
+      signal: u2.signal,
+      keepalive: true
     });
     return l2 && r$2(l2, {
       httpStatus: e3.status,
@@ -11260,9 +11262,9 @@ MixpanelRecorder.prototype._flushEvents = addOptOutCheckMixpanelLib(function(dat
     if (deviceId) {
       reqParams["$device_id"] = deviceId;
     }
-    var userId = this._mixpanel.get_property("$user_id");
-    if (userId) {
-      reqParams["$user_id"] = userId;
+    var userId2 = this._mixpanel.get_property("$user_id");
+    if (userId2) {
+      reqParams["$user_id"] = userId2;
     }
     if (CompressionStream) {
       var jsonStream = new Blob([eventsJson], { type: "application/json" }).stream();
@@ -13339,6 +13341,50 @@ function loadNoop(_src, onload) {
   onload();
 }
 var mixpanel = init_as_module(loadNoop);
+let generation = 0;
+let initialized = false;
+let userId;
+const subscribers = /* @__PURE__ */ new Set();
+const initializationSubscribers = /* @__PURE__ */ new Set();
+function invalidate$1() {
+  generation++;
+  subscribers.forEach((notify) => notify());
+}
+function beginInitialization() {
+  if (initialized) invalidate$1();
+  initialized = true;
+  userId = void 0;
+  initializationSubscribers.forEach((notify) => notify());
+}
+function identify$2(nextUserId) {
+  if (userId !== nextUserId) {
+    userId = nextUserId;
+    invalidate$1();
+  }
+}
+function capture() {
+  const captured = generation;
+  return () => captured === generation;
+}
+function onChange(notify) {
+  subscribers.add(notify);
+  return () => {
+    subscribers.delete(notify);
+  };
+}
+function onInitialization(notify) {
+  initializationSubscribers.add(notify);
+  return () => {
+    initializationSubscribers.delete(notify);
+  };
+}
+const trackingLifecycle = {
+  beginInitialization,
+  identify: identify$2,
+  capture,
+  onChange,
+  onInitialization
+};
 function createIdentifyReporter() {
   const reported = /* @__PURE__ */ new Set();
   return (stage, reason, httpStatus) => {
@@ -13373,16 +13419,16 @@ function waitForIdentifyReady(report) {
       if (!active) return;
       active = false;
       clearTimeout(timer);
-      window.removeEventListener("Tracker Ready", onReady);
+      window.removeEventListener("Tracker Ready", onReady2);
       if (!ready) report("readiness", "timeout");
       resolve(ready);
     };
-    const onReady = () => {
+    const onReady2 = () => {
       if (mixpanelService.isReady()) finish(true);
     };
     const timer = setTimeout(() => finish(false), 5e3);
-    window.addEventListener("Tracker Ready", onReady);
-    onReady();
+    window.addEventListener("Tracker Ready", onReady2);
+    onReady2();
   });
 }
 function waitForIdentifyStage(stage, timeout, run, report) {
@@ -13427,28 +13473,78 @@ function observeIdentifyResult(stage, report, onTimeout) {
   }, 5e3);
   return { complete };
 }
-const version = "1.1.8-alpha.0";
+const version = "1.1.8-alpha.2";
 const MIXPANEL_DISTINCT_ID_CACHE_KEY = "mp_distinct_id";
+const readinessSubscribers$1 = /* @__PURE__ */ new Set();
+let initializing = false;
+let initialization$2 = 0;
+let initializedConfig;
+function onReady$1(callback) {
+  readinessSubscribers$1.add(callback);
+  return () => {
+    readinessSubscribers$1.delete(callback);
+  };
+}
 const SDK_SUPER_PROPERTIES = {
   "Event Source": "sdk",
   "Reservamos Version": version
 };
 function init$2(mixpanelToken, debug = false, proxyUrl) {
+  validateConfiguration(mixpanelToken, proxyUrl);
+  const attempt = ++initialization$2;
+  initializing = true;
+  trackingLifecycle.beginInitialization();
+  if (initializedConfig && window.mixpanel === mixpanel) {
+    mixpanel.set_config({ debug });
+    initializing = false;
+    readinessSubscribers$1.forEach((notify) => notify());
+    return Promise.resolve();
+  }
   return new Promise((resolve) => {
     mixpanel.init(mixpanelToken, {
       debug,
       loaded: () => {
+        if (attempt !== initialization$2) {
+          resolve();
+          return;
+        }
         window.mixpanel = mixpanel;
         mixpanel.register({ ...SDK_SUPER_PROPERTIES });
+        initializedConfig = { token: mixpanelToken, proxyUrl };
+        initializing = false;
+        readinessSubscribers$1.forEach((notify) => notify());
         resolve();
       },
       ...proxyUrl && { api_host: proxyUrl }
     });
   });
 }
-function identify$1(userId, properties, report) {
-  mixpanel.identify(userId);
-  if (!updateCachedDistinctId(userId)) report == null ? void 0 : report("cache", "unavailable");
+function validateConfiguration(token, proxyUrl) {
+  if (initializedConfig && window.mixpanel === mixpanel && (initializedConfig.token !== token || initializedConfig.proxyUrl !== proxyUrl)) {
+    throw new Error(
+      "Changing the Mixpanel project or proxy requires a new page session."
+    );
+  }
+}
+function identify$1(userId2, properties, report) {
+  trackingLifecycle.identify(userId2);
+  mixpanel.identify(userId2);
+  if (!updateCachedDistinctId(userId2)) report == null ? void 0 : report("cache", "unavailable");
+  writePeopleProperties(properties, report);
+}
+function attachProperty(key, value) {
+  if (!isReady()) {
+    return;
+  }
+  mixpanel.people.union(key, [value]);
+}
+function setPeopleProperties(properties, report) {
+  if (!isReady()) {
+    return;
+  }
+  writePeopleProperties(properties, report);
+}
+function writePeopleProperties(properties, report) {
   if (!report) {
     mixpanel.people.set(properties);
     return;
@@ -13465,20 +13561,8 @@ function identify$1(userId, properties, report) {
     observer.complete("failed");
   }
 }
-function attachProperty(key, value) {
-  if (!isReady()) {
-    return;
-  }
-  mixpanel.people.union(key, [value]);
-}
-function setPeopleProperties(properties) {
-  if (!isReady()) {
-    return;
-  }
-  mixpanel.people.set(properties);
-}
 function isReady() {
-  return window.mixpanel !== void 0;
+  return !initializing && window.mixpanel !== void 0;
 }
 function track(eventName, properties) {
   if (!isReady()) {
@@ -13487,8 +13571,7 @@ function track(eventName, properties) {
   mixpanel.track(eventName, { ...properties, "Reservamos Version": version });
 }
 const getMixpanelDistinctId = () => {
-  var _a;
-  const distinctId = (_a = mixpanel == null ? void 0 : mixpanel.get_distinct_id) == null ? void 0 : _a.call(mixpanel);
+  const distinctId = isReady() ? mixpanel.get_distinct_id() : null;
   if (distinctId) {
     updateCachedDistinctId(distinctId);
     return distinctId;
@@ -13509,7 +13592,9 @@ function updateCachedDistinctId(distinctId) {
 }
 const mixpanelService = {
   init: init$2,
+  validateConfiguration,
   isReady,
+  onReady: onReady$1,
   track,
   identify: identify$1,
   attachProperty,
@@ -13520,6 +13605,23 @@ const DEFAULT_CACHE_NAME = "default_fingerprint_cache";
 const DEFAULT_CACHE_TIME_IN_DAYS = 7;
 const PROXY_QUERY_PARAM = "apiKey=<apiKey>&version=<version>&loaderVersion=<loaderVersion>";
 let fingerprintAgentReady = false;
+let initialization$1 = 0;
+let startedInitialization = -1;
+const readinessSubscribers = /* @__PURE__ */ new Set();
+const waitingConsumers = /* @__PURE__ */ new Set();
+let pendingIdentification;
+function onReady(notify) {
+  readinessSubscribers.add(notify);
+  return () => {
+    readinessSubscribers.delete(notify);
+  };
+}
+function invalidate() {
+  initialization$1++;
+  fingerprintAgentReady = false;
+  pendingIdentification = void 0;
+  waitingConsumers.forEach((cancel) => cancel());
+}
 const getExpirationDate = (cacheTimeInDays) => {
   const currentDate = /* @__PURE__ */ new Date();
   const futureDate = new Date(
@@ -13565,7 +13667,9 @@ async function initFingerprint(apiKey, proxyUrl) {
     customEndpointArray.unshift(proxyUrl);
     customScriptEndpointArray.unshift(buildProxyUrl(proxyUrl));
   }
-  fingerprintAgentReady = false;
+  if (startedInitialization === initialization$1) invalidate();
+  startedInitialization = initialization$1;
+  const attempt = initialization$1;
   window.fingerprintConfig = {};
   const client = new FpjsClient({
     loadOptions: {
@@ -13577,19 +13681,21 @@ async function initFingerprint(apiKey, proxyUrl) {
   window.fpClient = client;
   try {
     await client.init();
-    if (window.fpClient === client) {
+    if (window.fpClient === client && attempt === initialization$1) {
       fingerprintAgentReady = true;
+      readinessSubscribers.forEach((notify) => notify());
     }
   } catch (error) {
-    if (window.fpClient === client) {
+    if (window.fpClient === client && attempt === initialization$1) {
       fingerprintAgentReady = false;
+      waitingConsumers.forEach((cancel) => cancel());
     }
     console.error("Error initializing identification service:", error);
     throw error;
   }
 }
-async function getFingerprint(cacheOnly = false) {
-  return readFingerprint(cacheOnly);
+async function getFingerprint(cacheOnly = false, context) {
+  return readFingerprint(cacheOnly, context);
 }
 function getFingerprintForIdentify(context) {
   return readFingerprint(false, context);
@@ -13605,21 +13711,59 @@ async function readFingerprint(cacheOnly, context) {
   const { visitorId } = await requestIdentification(false, context);
   return visitorId;
 }
-async function identifyVisitor(ignoreCache = false) {
-  return requestIdentification(ignoreCache);
+async function identifyVisitor(ignoreCache = false, context) {
+  return requestIdentification(ignoreCache, context);
 }
 async function requestIdentification(ignoreCache, context) {
+  if (!ignoreCache && (pendingIdentification == null ? void 0 : pendingIdentification.isCurrent())) {
+    for (const participant of pendingIdentification.contexts) {
+      if (participant && !participant.isActive())
+        pendingIdentification.contexts.delete(participant);
+    }
+    pendingIdentification.contexts.add(context);
+    return pendingIdentification.promise;
+  }
+  const contexts = /* @__PURE__ */ new Set([context]);
+  const attempt = initialization$1;
+  const currentLifecycle = trackingLifecycle.capture();
+  const isCurrent = () => attempt === initialization$1 && currentLifecycle();
+  const sharedContext = {
+    isActive: () => isCurrent() && [...contexts].some(
+      (participant) => !participant || participant.isActive()
+    ),
+    report: (...args) => {
+      for (const participant of contexts) {
+        if (participant == null ? void 0 : participant.isActive()) participant.report(...args);
+      }
+    }
+  };
+  const request = {
+    contexts,
+    isCurrent,
+    promise: performIdentification(
+      ignoreCache,
+      sharedContext,
+      () => contexts.has(void 0)
+    )
+  };
+  pendingIdentification = request;
+  const clear = () => {
+    if (pendingIdentification === request) pendingIdentification = void 0;
+  };
+  void request.promise.then(clear, clear);
+  return request.promise;
+}
+async function performIdentification(ignoreCache, context, hasUnscopedConsumer) {
   if (!isFingerprintReady()) {
     throw new Error("Identification service is not initialized.");
   }
   try {
     const result = await window.fpClient.getVisitorData({}, ignoreCache);
-    if (!context || context.isActive()) {
+    if (context.isActive()) {
       try {
         setCachedFingerprint(result.visitorId);
-      } catch (error) {
-        if (!context) throw error;
-        context.report("cache", "unavailable");
+      } catch {
+        context == null ? void 0 : context.report("cache", "unavailable");
       }
       if (typeof result.visitorFound === "boolean") {
         try {
@@ -13627,8 +13771,9 @@ async function requestIdentification(ignoreCache, context) {
             "Visitor Found": result.visitorFound
           });
         } catch (error) {
-          if (context) context.report("fingerprint", "failed");
-          else console.error("Error updating Mixpanel visitor profile:", error);
+          context.report("fingerprint", "failed");
+          if (hasUnscopedConsumer())
+            console.error("Error updating Mixpanel visitor profile:", error);
         }
       }
     }
@@ -13640,10 +13785,46 @@ async function requestIdentification(ignoreCache, context) {
       cacheHit: result.cacheHit
     };
   } catch (error) {
-    if (!context) console.error("Error retrieving fingerprint:", error);
+    if (hasUnscopedConsumer())
+      console.error("Error retrieving fingerprint:", error);
     throw error;
   }
 }
+function waitForFingerprintId(timeoutMs = 2e3) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 2147483647)
+    return Promise.resolve(null);
+  const cached = getCachedFingerprint();
+  if (cached) return Promise.resolve(cached);
+  return new Promise((resolve) => {
+    let active = true;
+    let started = false;
+    const finish = (visitorId) => {
+      if (!active) return;
+      active = false;
+      clearTimeout(timer);
+      stopReady();
+      stopLifecycle();
+      waitingConsumers.delete(cancel);
+      resolve(visitorId);
+    };
+    const cancel = () => finish(null);
+    const start = () => {
+      if (!active || started || !isFingerprintReady()) return;
+      started = true;
+      const identity = getFingerprint(false, {
+        // Caller timeout ends waiting; the shared request still checks its lifecycle.
+        isActive: () => true,
+        report: () => void 0
+      });
+      void identity.then((visitorId) => finish(visitorId || null), cancel);
+    };
+    const timer = setTimeout(cancel, timeoutMs);
+    const stopReady = onReady(start);
+    const stopLifecycle = trackingLifecycle.onChange(cancel);
+    waitingConsumers.add(cancel);
+    start();
+  });
+}
 function isFingerprintReady() {
   return window.fpClient !== void 0 && fingerprintAgentReady;
 }
@@ -13652,8 +13833,169 @@ const fingerprintService = {
   getFingerprint,
   identifyVisitor,
   isFingerprintReady,
-  getCachedFingerprint
-};
+  onReady,
+  invalidate,
+  getCachedFingerprint,
+  waitForFingerprintId
+};
+trackingLifecycle.onInitialization(invalidate);
+function createPendingWorkQueue(options) {
+  const entries = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  let active = 0;
+  let draining = false;
+  let unsubscribe;
+  let timer;
+  function diagnostic(entry, reason) {
+    console.error("Tracking recovery diagnostic", {
+      eventName: entry.eventName,
+      stage: options.stage,
+      reason
+    });
+  }
+  function resolveForeground(entry) {
+    var _a;
+    (_a = entry.resolve) == null ? void 0 : _a.call(entry);
+    entry.resolve = void 0;
+  }
+  function close(entry, reason) {
+    if (entry.state === "closed") return;
+    entry.state = "closed";
+    entries.delete(entry);
+    bytes -= entry.bytes;
+    resolveForeground(entry);
+    if (reason) diagnostic(entry, reason);
+  }
+  function schedule() {
+    clearTimeout(timer);
+    timer = void 0;
+    if (entries.size === 0) {
+      unsubscribe == null ? void 0 : unsubscribe();
+      unsubscribe = void 0;
+      return;
+    }
+    let next = Infinity;
+    for (const entry of entries) {
+      next = Math.min(next, entry.deadline);
+      if (entry.resolve) next = Math.min(next, entry.foregroundDeadline);
+    }
+    timer = setTimeout(drain, Math.max(0, next - Date.now()));
+  }
+  function drain() {
+    if (draining) return;
+    draining = true;
+    try {
+      for (const entry of entries) {
+        if (!entry.isCurrent()) close(entry, "identity_changed");
+        else if (Date.now() >= entry.deadline) close(entry, "timeout");
+        else if (entry.resolve && Date.now() >= entry.foregroundDeadline) {
+          resolveForeground(entry);
+        }
+      }
+      for (const entry of entries) {
+        if (active >= options.maxActive || !options.isReady()) break;
+        if (entry.state !== "waiting") continue;
+        entry.state = "active";
+        active++;
+        const isActive = () => entry.state === "active" && Date.now() < entry.deadline && entry.isCurrent();
+        const finish = (failed = false) => {
+          if (failed && isActive()) diagnostic(entry, "failed");
+          close(entry);
+          active--;
+          drain();
+        };
+        try {
+          void Promise.resolve(entry.run(isActive)).then(
+            () => finish(),
+            () => finish(true)
+          );
+        } catch {
+          finish(true);
+        }
+      }
+    } finally {
+      draining = false;
+      schedule();
+    }
+  }
+  function enqueue(work) {
+    if (work.bytes > options.maxBytes) {
+      diagnostic(work, "capacity");
+      return Promise.resolve();
+    }
+    while (entries.size >= options.maxEntries || bytes + work.bytes > options.maxBytes) {
+      const oldest = [...entries].find((entry) => entry.state === "waiting");
+      if (!oldest) {
+        diagnostic(work, "capacity");
+        return Promise.resolve();
+      }
+      close(oldest, "capacity");
+    }
+    return new Promise((resolve) => {
+      const entry = {
+        ...work,
+        state: "waiting",
+        deadline: Date.now() + options.lifetime,
+        foregroundDeadline: Date.now() + options.wait,
+        resolve
+      };
+      entries.add(entry);
+      bytes += entry.bytes;
+      unsubscribe ?? (unsubscribe = options.subscribe(drain));
+      drain();
+    });
+  }
+  return { enqueue };
+}
+const observations = createPendingWorkQueue({
+  isReady: () => fingerprintService.isFingerprintReady(),
+  subscribe(notify) {
+    const stopReady = fingerprintService.onReady(notify);
+    const stopIdentity = trackingLifecycle.onChange(notify);
+    return () => {
+      stopReady();
+      stopIdentity();
+    };
+  },
+  maxEntries: 100,
+  maxBytes: 1024 * 1024,
+  maxActive: 3,
+  lifetime: 1e4,
+  wait: 0,
+  stage: "fingerprint"
+});
+function deferBotDetection(eventName, distinctId, isCurrent) {
+  void observations.enqueue({
+    eventName,
+    bytes: new Blob([eventName, distinctId ?? ""]).size,
+    isCurrent,
+    async run(isActive) {
+      let stage = "fingerprint";
+      try {
+        const identification = await fingerprintService.identifyVisitor(true, {
+          isActive,
+          report: () => void 0
+        });
+        if (!isActive() || !identification.requestId) return;
+        stage = "relay";
+        await botDetectionRelayService.relay({
+          requestId: identification.requestId,
+          visitorId: identification.visitorId,
+          ...distinctId && { distinctId },
+          eventName
+        });
+      } catch {
+        if (isActive()) {
+          console.error("Bot Detection diagnostic", {
+            eventName,
+            stage,
+            reason: "failed"
+          });
+        }
+      }
+    }
+  });
+}
 let environment;
 let appName;
 const origin = window.location.origin;
@@ -13792,7 +14134,7 @@ const tripSchema = z.object({
   "Departure Origin Terminal": stringField("Departure Origin Terminal"),
   "Departure Price": numberField("Departure Price"),
   "Departure Route": stringField("Departure Route"),
-  "Departure Stops": intField("Departure Stops"),
+  "Departure Stops": z.number().int(),
   "Departure Time": dateField("Departure Time"),
   "Departure Transport Type": stringField("Departure Transport Type"),
   "Departure Transporter": stringField("Departure Transporter"),
@@ -13806,7 +14148,7 @@ const tripSchema = z.object({
   "Return Origin Terminal": stringField("Return Origin Terminal").optional(),
   "Return Price": numberField("Return Price").optional(),
   "Return Route": stringField("Return Route").optional(),
-  "Return Stops": intField("Return Stops").optional(),
+  "Return Stops": z.number().int().optional(),
   "Return Time": dateField("Return Time").optional(),
   "Return Transport Type": stringField("Return Transport Type").optional(),
   "Return Transporter": stringField("Return Transporter").optional(),
@@ -13819,7 +14161,8 @@ const passengersCreatedSchema = z.object({
   "Trip Count": intField("Trip Count").optional(),
   "Total": numberField("Total"),
   "product": productValidation,
-  "Passengers": arrayField(passengerSchema, "Passengers", 1).optional()
+  "Passengers": arrayField(passengerSchema, "Passengers", 1).optional(),
+  "Coupon": stringField("Coupon").optional()
 }).strict();
 const EVENT_NAME$8 = "Passengers Created";
 function trackPassengersCreated(eventProps, meta = {}) {
@@ -13887,7 +14230,8 @@ const purchaseConfirmationSchema = z.object({
   "Operation Id": z.string().min(1, "Operation Id is required"),
   "Payment Status": z.enum(["confirmed", "pending_pix"]),
   "Payment Type": z.string().optional(),
-  "Total": z.number().optional()
+  "Total": z.number().optional(),
+  "product": productValidation.optional()
 }).strict();
 const EVENT_NAME$4 = "Purchase Confirmation Viewed";
 function trackPurchaseConfirmation(eventData, meta = {}) {
@@ -14071,6 +14415,7 @@ const validatorService = {
   parseIdentifyProps,
   validateProps
 };
+let initialization = 0;
 function onLoaded() {
   window.dispatchEvent(new CustomEvent("Tracker Ready"));
 }
@@ -14085,19 +14430,30 @@ async function init$1(config) {
     identifyProxyUrl,
     appName: appName2
   } = config;
+  mixpanelService.validateConfiguration(mixpanelToken, mixpanelProxyUrl);
+  const attempt = ++initialization;
+  const isCurrent = () => attempt === initialization;
   await mixpanelService.init(mixpanelToken, debug, mixpanelProxyUrl);
+  if (!isCurrent()) return;
   configService.setEnvironment(isSandbox ? "sandbox" : "prod");
   if (appName2) {
     configService.setAppName(appName2);
   }
   a$1.setConfig(configService.getCoreAPIConfig());
   onLoaded();
+  if (!isCurrent()) return;
   await Promise.all([
     initializeOptionalStage(
       "fingerprint",
-      () => fingerprintService.initFingerprint(identificationKey, identifyProxyUrl)
+      () => isCurrent() ? fingerprintService.initFingerprint(
+        identificationKey,
+        identifyProxyUrl
+      ) : Promise.resolve()
     ),
-    initializeOptionalStage("geolocation", () => geolocationService.init())
+    initializeOptionalStage(
+      "geolocation",
+      () => isCurrent() ? geolocationService.init() : Promise.resolve()
+    )
   ]);
 }
 function initializeOptionalStage(stage, initialize) {
@@ -14323,6 +14679,20 @@ const geolocationService = {
   getCoordinates,
   getGeolocationSource
 };
+function snapshotEventData(value) {
+  if (Array.isArray(value))
+    return value.map((item) => snapshotEventData(item));
+  if (value instanceof Date) return new Date(value.getTime());
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        snapshotEventData(item)
+      ])
+    );
+  }
+  return value;
+}
 const FP_TRIGGER_EVENTS = ["Search", "View Results"];
 const EXTRA_UTM_FIELDS = {
   utm_brand: "UTM Brand",
@@ -14377,15 +14747,17 @@ async function tryTrackEvent(trackEventCallback, eventName = "Track Event Error"
     const ready = await new Promise((resolve) => {
       const finish = (isReady2) => {
         clearTimeout(timer);
-        window.removeEventListener("Tracker Ready", onReady);
+        window.removeEventListener("Tracker Ready", onReady2);
+        unsubscribe();
         resolve(isReady2);
       };
-      const onReady = () => {
+      const onReady2 = () => {
         if (mixpanelService.isReady()) finish(true);
       };
       const timer = setTimeout(() => finish(mixpanelService.isReady()), 5e3);
-      window.addEventListener("Tracker Ready", onReady);
-      onReady();
+      const unsubscribe = mixpanelService.onReady(onReady2);
+      window.addEventListener("Tracker Ready", onReady2);
+      onReady2();
     });
     if (!ready) {
       console.error("Tracking diagnostic", {
@@ -14406,28 +14778,94 @@ async function tryTrackEvent(trackEventCallback, eventName = "Track Event Error"
     });
   }
 }
+const pendingEvents = createPendingWorkQueue({
+  isReady: () => mixpanelService.isReady(),
+  subscribe(notify) {
+    const stopReady = mixpanelService.onReady(notify);
+    const stopIdentity = trackingLifecycle.onChange(notify);
+    window.addEventListener("Tracker Ready", notify);
+    return () => {
+      stopReady();
+      stopIdentity();
+      window.removeEventListener("Tracker Ready", notify);
+    };
+  },
+  maxEntries: 100,
+  maxBytes: 1024 * 1024,
+  maxActive: 100,
+  lifetime: 6e4,
+  wait: 5e3,
+  stage: "readiness"
+});
 function trackEvent(eventName, eventProperties, meta = {}) {
-  return tryTrackEvent(
-    () => submitEvent(eventName, eventProperties, meta),
-    eventName
-  );
+  const isCurrent = trackingLifecycle.capture();
+  const trackingParams = extractTrackingParams();
+  if (mixpanelService.isReady()) {
+    return submitEvent(
+      eventName,
+      eventProperties,
+      meta,
+      isCurrent,
+      trackingParams
+    );
+  }
+  try {
+    validatorService.parseEventProps(eventName, eventProperties);
+  } catch (error) {
+    trackEventError(eventName, error, eventProperties);
+    return Promise.resolve();
+  }
+  let snapshot2;
+  let bytes;
+  try {
+    const serialized = JSON.stringify(
+      { eventName, eventProperties, meta, trackingParams },
+      (_key, value) => {
+        if (typeof value === "function" || typeof value === "symbol")
+          throw new Error();
+        return value === void 0 ? null : value;
+      }
+    );
+    bytes = new Blob([serialized]).size;
+    if (bytes > 1024 * 1024) throw new Error();
+    snapshot2 = snapshotEventData({ eventProperties, meta });
+  } catch {
+    console.error("Tracking recovery diagnostic", {
+      eventName,
+      stage: "readiness",
+      reason: "snapshot_unavailable"
+    });
+    return Promise.resolve();
+  }
+  return pendingEvents.enqueue({
+    eventName,
+    bytes,
+    isCurrent,
+    run: (isActive) => submitEvent(
+      eventName,
+      snapshot2.eventProperties,
+      snapshot2.meta,
+      isActive,
+      trackingParams
+    )
+  });
 }
-async function submitEvent(eventName, eventProperties, meta) {
+async function submitEvent(eventName, eventProperties, meta, isCurrent, trackingParams) {
+  const observationContext = trackingLifecycle.capture();
   try {
     validatorService.parseEventProps(eventName, eventProperties);
     const distinctId = mixpanelService.getMixpanelDistinctId();
     const botDetectionEnabled = botDetectionRelayService.isEnabledFor(eventName);
     let fingerprint = "";
-    if (botDetectionEnabled) {
+    if (botDetectionEnabled || FP_TRIGGER_EVENTS.includes(eventName)) {
       try {
         fingerprint = fingerprintService.getCachedFingerprint() ?? "";
       } catch (error) {
         console.error("Error reading cached fingerprint:", error);
       }
     } else {
-      const cacheOnly = !FP_TRIGGER_EVENTS.includes(eventName);
       try {
-        fingerprint = await fingerprintService.getFingerprint(cacheOnly);
+        fingerprint = await fingerprintService.getFingerprint(true);
       } catch {
         console.error("Tracking diagnostic", {
           eventName,
@@ -14449,7 +14887,6 @@ async function submitEvent(eventName, eventProperties, meta) {
     const defaultProperties = {
       "User Fingerprint": fingerprint
     };
-    const trackingParams = extractTrackingParams();
     const simplifiedData = flattenEventData(eventProperties);
     const properties = {
       ...defaultProperties,
@@ -14458,28 +14895,40 @@ async function submitEvent(eventName, eventProperties, meta) {
       ...defaultCoordinates,
       ...meta
     };
-    mixpanelService.track(eventName, properties);
+    if (!isCurrent()) return;
+    try {
+      mixpanelService.track(eventName, properties);
+    } catch {
+      console.error("Tracking diagnostic", {
+        eventName,
+        stage: "submission",
+        reason: "uncertain"
+      });
+      return;
+    }
     if (botDetectionEnabled) {
-      void identifyAndRelayFingerprint(eventName, distinctId);
+      deferBotDetection(eventName, distinctId, observationContext);
+    } else if (FP_TRIGGER_EVENTS.includes(eventName)) {
+      void refreshFingerprint(eventName, observationContext);
     }
   } catch (error) {
     console.error(`Error tracking event '${eventName}':`, error);
     trackEventError(eventName, error, eventProperties);
   }
 }
-async function identifyAndRelayFingerprint(eventName, distinctId) {
+async function refreshFingerprint(eventName, isCurrent) {
+  const deadline = Date.now() + 1e4;
   try {
-    if (!fingerprintService.isFingerprintReady()) return;
-    const identification = await fingerprintService.identifyVisitor(true);
-    if (!identification.requestId) return;
-    await botDetectionRelayService.relay({
-      requestId: identification.requestId,
-      visitorId: identification.visitorId,
-      ...distinctId && { distinctId },
-      eventName
+    await fingerprintService.getFingerprint(false, {
+      isActive: () => isCurrent() && Date.now() < deadline,
+      report: () => void 0
+    });
+  } catch {
+    console.error("Tracking diagnostic", {
+      eventName,
+      stage: "fingerprint",
+      reason: "failed"
     });
-  } catch (error) {
-    console.error(`Error running Bot Detection for '${eventName}':`, error);
   }
 }
 function extractTrackingParams() {
@@ -14598,6 +15047,7 @@ async function requestAnonymousProfile(payload, report) {
 }
 const KNOWN_PROPERTIES = ["firstName", "lastName", "email", "phone"];
 const FINGERPRINT_PROPERTY = "Known Fingerprints";
+let latestAttempt = 0;
 function mapProperties(properties) {
   const parsedProperties = {
     $first_name: properties == null ? void 0 : properties.firstName,
@@ -14616,7 +15066,7 @@ function mapProperties(properties) {
   );
   return { ...parsedProperties, ...additionalProperties };
 }
-const identifyWithLocation = async (userId, properties, report) => {
+const identifyWithLocation = async (userId2, properties, report) => {
   var _a, _b, _c;
   let observer;
   try {
@@ -14653,7 +15103,7 @@ const identifyWithLocation = async (userId, properties, report) => {
         body: JSON.stringify({
           profile_params: {
             ...properties,
-            distinct_id: userId
+            distinct_id: userId2
           }
         })
       }
@@ -14667,13 +15117,59 @@ const identifyWithLocation = async (userId, properties, report) => {
     else report("datalake", "failed");
   }
 };
-async function identify(userId, properties = {}) {
+async function enrichProfileAndLocation(userId2, properties, isActive, report) {
+  const profile = await waitForIdentifyStage(
+    "profile",
+    3e3,
+    (context) => isActive() ? createAnonymousProfileForIdentify({ ...properties }, context.report) : Promise.resolve(void 0),
+    report
+  );
+  if (!isActive()) return;
+  const enriched = {
+    ...properties,
+    ...profile && { reservamos_one_id: profile.id }
+  };
+  if (profile) {
+    try {
+      mixpanelService.setPeopleProperties(
+        { reservamos_one_id: profile.id },
+        report
+      );
+    } catch {
+      report("profile", "failed");
+    }
+  }
+  void identifyWithLocation(userId2, enriched, report);
+}
+async function enrichFingerprint(isActive, report) {
+  const fingerprint = await waitForIdentifyStage(
+    "fingerprint",
+    2e3,
+    (context) => !isActive() ? Promise.resolve("") : getFingerprintForIdentify({
+      isActive: () => context.isActive() && isActive(),
+      report: context.report
+    }),
+    report
+  );
+  if (!fingerprint || !isActive()) return;
+  try {
+    mixpanelService.attachProperty(FINGERPRINT_PROPERTY, fingerprint);
+  } catch {
+    report("fingerprint", "failed");
+  }
+}
+async function identify(userId2, properties = {}) {
+  const attempt = ++latestAttempt;
+  const input = { ...properties };
   const report = createIdentifyReporter();
-  if (!await waitForIdentifyReady(report)) return;
+  const initialLifecycle = trackingLifecycle.capture();
+  if (!await waitForIdentifyReady(report) || attempt !== latestAttempt || !initialLifecycle())
+    return;
+  let submitted = false;
   try {
     try {
-      validatorService.parseIdentifyProps(properties);
-      if (!userId) {
+      validatorService.parseIdentifyProps(input);
+      if (!userId2) {
         report("validation", "invalid_input");
         return;
       }
@@ -14681,38 +15177,22 @@ async function identify(userId, properties = {}) {
       report("validation", "invalid_input");
       return;
     }
-    const anonymousProfile = await waitForIdentifyStage(
-      "profile",
-      3e3,
-      (context) => createAnonymousProfileForIdentify({ ...properties }, context.report),
-      report
-    );
-    if (anonymousProfile) {
-      properties.reservamos_one_id = anonymousProfile.id;
-    }
-    const mappedProps = mapProperties(properties);
     try {
-      mixpanelService.identify(userId, mappedProps, report);
+      mixpanelService.identify(userId2, mapProperties(input), report);
     } catch {
       report("mixpanel", "failed");
+      return;
     }
-    const fingerprint = await waitForIdentifyStage(
-      "fingerprint",
-      2e3,
-      getFingerprintForIdentify,
-      report
-    );
-    if (fingerprint) {
-      try {
-        mixpanelService.attachProperty(FINGERPRINT_PROPERTY, fingerprint);
-      } catch {
-        report("fingerprint", "failed");
-      }
-    }
-  } catch {
-    report("mixpanel", "failed");
+    const currentLifecycle = trackingLifecycle.capture();
+    const isActive = () => attempt === latestAttempt && currentLifecycle();
+    const scopedReport = (...args) => {
+      if (isActive()) report(...args);
+    };
+    submitted = true;
+    void enrichProfileAndLocation(userId2, input, isActive, scopedReport);
+    void enrichFingerprint(isActive, scopedReport);
   } finally {
-    void identifyWithLocation(userId, properties, report);
+    if (!submitted) void identifyWithLocation(userId2, { ...input }, report);
   }
 }
 z.object({
@@ -14914,6 +15394,7 @@ const analytics = {
   identify,
   identifiers: {
     getFingerprintId: fingerprintService.getCachedFingerprint,
+    waitForFingerprintId: fingerprintService.waitForFingerprintId,
     getDistinctId: mixpanelService.getMixpanelDistinctId
   },
   profiles: {