@reservamos/browser-analytics 1.1.7 → 1.1.8-alpha.1

package/dist/browser-analytics.esm.js

@@ -11260,9 +11260,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 +13339,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 +13417,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,32 +13471,63 @@ function observeIdentifyResult(stage, report, onTimeout) {
   }, 5e3);
   return { complete };
 }
-const version = "1.1.7";
+const version = "1.1.8-alpha.1";
 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);
-  try {
-    updateCachedDistinctId(userId);
-  } catch {
-    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");
   if (!report) {
     mixpanel.people.set(properties);
     return;
@@ -13482,7 +13557,7 @@ function setPeopleProperties(properties) {
   mixpanel.people.set(properties);
 }
 function isReady() {
-  return window.mixpanel !== void 0;
+  return !initializing && window.mixpanel !== void 0;
 }
 function track(eventName, properties) {
   if (!isReady()) {
@@ -13491,22 +13566,31 @@ function track(eventName, properties) {
   mixpanel.track(eventName, { ...properties, "Reservamos Version": version });
 }
 const getMixpanelDistinctId = () => {
-  const cachedId = localStorage.getItem(MIXPANEL_DISTINCT_ID_CACHE_KEY);
-  if (mixpanel && mixpanel.get_distinct_id) {
-    const distinctId = mixpanel.get_distinct_id();
+  var _a;
+  const distinctId = (_a = mixpanel == null ? void 0 : mixpanel.get_distinct_id) == null ? void 0 : _a.call(mixpanel);
+  if (distinctId) {
     updateCachedDistinctId(distinctId);
     return distinctId;
-  } else if (cachedId) {
-    return cachedId;
   }
-  return null;
+  try {
+    return localStorage.getItem(MIXPANEL_DISTINCT_ID_CACHE_KEY);
+  } catch {
+    return null;
+  }
 };
 function updateCachedDistinctId(distinctId) {
-  localStorage.setItem(MIXPANEL_DISTINCT_ID_CACHE_KEY, distinctId);
+  try {
+    localStorage.setItem(MIXPANEL_DISTINCT_ID_CACHE_KEY, distinctId);
+    return true;
+  } catch {
+    return false;
+  }
 }
 const mixpanelService = {
   init: init$2,
+  validateConfiguration,
   isReady,
+  onReady: onReady$1,
   track,
   identify: identify$1,
   attachProperty,
@@ -13517,6 +13601,18 @@ 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;
+const readinessSubscribers = /* @__PURE__ */ new Set();
+function onReady(notify) {
+  readinessSubscribers.add(notify);
+  return () => {
+    readinessSubscribers.delete(notify);
+  };
+}
+function invalidate() {
+  initialization$1++;
+  fingerprintAgentReady = false;
+}
 const getExpirationDate = (cacheTimeInDays) => {
   const currentDate = /* @__PURE__ */ new Date();
   const futureDate = new Date(
@@ -13528,8 +13624,8 @@ const getCachedFingerprint = () => {
   return readCachedFingerprint();
 };
 function readCachedFingerprint(context) {
-  const { cacheName = DEFAULT_CACHE_NAME } = window.fingerprintConfig;
   try {
+    const { cacheName = DEFAULT_CACHE_NAME } = window.fingerprintConfig ?? {};
     const cachedData = JSON.parse(localStorage.getItem(cacheName) || "null");
     if (cachedData && cachedData.expiresAt > Date.now()) {
       return cachedData.fingerprint;
@@ -13562,7 +13658,8 @@ async function initFingerprint(apiKey, proxyUrl) {
     customEndpointArray.unshift(proxyUrl);
     customScriptEndpointArray.unshift(buildProxyUrl(proxyUrl));
   }
-  fingerprintAgentReady = false;
+  invalidate();
+  const attempt = initialization$1;
   window.fingerprintConfig = {};
   const client = new FpjsClient({
     loadOptions: {
@@ -13574,42 +13671,37 @@ 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;
     }
     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);
 }
 async function readFingerprint(cacheOnly, context) {
-  if (!window.fingerprintConfig) {
-    if (cacheOnly) {
-      return "";
-    }
-    throw new Error("Fingerprint configuration is not initialized.");
-  }
   const cachedFingerprint = readCachedFingerprint(context);
   if (cachedFingerprint) {
     return cachedFingerprint;
   }
-  if (cacheOnly || !isFingerprintReady()) {
+  if (cacheOnly || !window.fingerprintConfig || !isFingerprintReady()) {
     return "";
   }
   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 (!isFingerprintReady()) {
@@ -13620,9 +13712,8 @@ async function requestIdentification(ignoreCache, context) {
     if (!context || 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 {
@@ -13655,8 +13746,168 @@ const fingerprintService = {
   getFingerprint,
   identifyVisitor,
   isFingerprintReady,
+  onReady,
+  invalidate,
   getCachedFingerprint
 };
+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;
@@ -13795,7 +14046,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"),
@@ -13809,7 +14060,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(),
@@ -14074,6 +14325,7 @@ const validatorService = {
   parseIdentifyProps,
   validateProps
 };
+let initialization = 0;
 function onLoaded() {
   window.dispatchEvent(new CustomEvent("Tracker Ready"));
 }
@@ -14088,22 +14340,49 @@ 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);
-  try {
-    await fingerprintService.initFingerprint(
-      identificationKey,
-      identifyProxyUrl
-    );
-  } catch (error) {
-    console.error("Error initializing identification service:", error);
-  }
-  await geolocationService.init();
+  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",
+      () => isCurrent() ? fingerprintService.initFingerprint(
+        identificationKey,
+        identifyProxyUrl
+      ) : Promise.resolve()
+    ),
+    initializeOptionalStage(
+      "geolocation",
+      () => isCurrent() ? geolocationService.init() : Promise.resolve()
+    )
+  ]);
+}
+function initializeOptionalStage(stage, initialize) {
+  return new Promise((resolve) => {
+    let active = true;
+    const finish = (reason) => {
+      if (!active) return;
+      active = false;
+      clearTimeout(timer);
+      if (reason)
+        console.error("SDK initialization diagnostic", { stage, reason });
+      resolve();
+    };
+    const timer = setTimeout(() => finish("timeout"), 3e3);
+    void Promise.resolve().then(initialize).then(
+      () => finish(),
+      () => finish("failed")
+    );
+  });
 }
 function isTrackerReady() {
   return mixpanelService.isReady();
@@ -14310,6 +14589,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",
@@ -14359,32 +14652,137 @@ function trackEventError(eventName, error, payload) {
     }
   });
 }
-async function tryTrackEvent(trackEventCallback) {
-  if (mixpanelService.isReady()) {
+async function tryTrackEvent(trackEventCallback, eventName = "Track Event Error") {
+  if (!mixpanelService.isReady()) {
+    const ready = await new Promise((resolve) => {
+      const finish = (isReady2) => {
+        clearTimeout(timer);
+        window.removeEventListener("Tracker Ready", onReady2);
+        unsubscribe();
+        resolve(isReady2);
+      };
+      const onReady2 = () => {
+        if (mixpanelService.isReady()) finish(true);
+      };
+      const timer = setTimeout(() => finish(mixpanelService.isReady()), 5e3);
+      const unsubscribe = mixpanelService.onReady(onReady2);
+      window.addEventListener("Tracker Ready", onReady2);
+      onReady2();
+    });
+    if (!ready) {
+      console.error("Tracking diagnostic", {
+        eventName,
+        stage: "readiness",
+        reason: "timeout"
+      });
+      return;
+    }
+  }
+  try {
     await trackEventCallback();
-  } else {
-    window.addEventListener("Tracker Ready", async () => {
-      await trackEventCallback();
+  } catch {
+    console.error("Tracking diagnostic", {
+      eventName,
+      stage: "submission",
+      reason: "failed"
     });
   }
 }
-async function trackEvent(eventName, eventProperties, meta = {}) {
-  if (!mixpanelService.isReady()) {
-    throw new Error("Mixpanel is not initialized.");
+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 = {}) {
+  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, isCurrent, trackingParams) {
+  const observationContext = trackingLifecycle.capture();
   try {
     validatorService.parseEventProps(eventName, eventProperties);
     const distinctId = mixpanelService.getMixpanelDistinctId();
     const botDetectionEnabled = botDetectionRelayService.isEnabledFor(eventName);
-    let fingerprint;
-    let fingerprintRequestId;
-    if (botDetectionEnabled && fingerprintService.isFingerprintReady()) {
-      const identification = await fingerprintService.identifyVisitor(true);
-      fingerprint = identification.visitorId;
-      fingerprintRequestId = identification.requestId;
+    let fingerprint = "";
+    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);
-      fingerprint = await fingerprintService.getFingerprint(cacheOnly);
+      try {
+        fingerprint = await fingerprintService.getFingerprint(true);
+      } catch {
+        console.error("Tracking diagnostic", {
+          eventName,
+          stage: "fingerprint",
+          reason: "failed"
+        });
+      }
     }
     const defaultCoordinates = {};
     const coordinates = geolocationService.getCoordinates();
@@ -14399,7 +14797,6 @@ async function trackEvent(eventName, eventProperties, meta = {}) {
     const defaultProperties = {
       "User Fingerprint": fingerprint
     };
-    const trackingParams = extractTrackingParams();
     const simplifiedData = flattenEventData(eventProperties);
     const properties = {
       ...defaultProperties,
@@ -14408,20 +14805,42 @@ async function trackEvent(eventName, eventProperties, meta = {}) {
       ...defaultCoordinates,
       ...meta
     };
-    mixpanelService.track(eventName, properties);
-    if (fingerprintRequestId) {
-      void botDetectionRelayService.relay({
-        requestId: fingerprintRequestId,
-        visitorId: fingerprint,
-        ...distinctId && { distinctId },
-        eventName
+    if (!isCurrent()) return;
+    try {
+      mixpanelService.track(eventName, properties);
+    } catch {
+      console.error("Tracking diagnostic", {
+        eventName,
+        stage: "submission",
+        reason: "uncertain"
       });
+      return;
+    }
+    if (botDetectionEnabled) {
+      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 refreshFingerprint(eventName, isCurrent) {
+  const deadline = Date.now() + 1e4;
+  try {
+    await fingerprintService.getFingerprint(false, {
+      isActive: () => isCurrent() && Date.now() < deadline,
+      report: () => void 0
+    });
+  } catch {
+    console.error("Tracking diagnostic", {
+      eventName,
+      stage: "fingerprint",
+      reason: "failed"
+    });
+  }
+}
 function extractTrackingParams() {
   try {
     const urlParams = new URLSearchParams(window.location.search);
@@ -14556,7 +14975,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 {
@@ -14593,7 +15012,7 @@ const identifyWithLocation = async (userId, properties, report) => {
         body: JSON.stringify({
           profile_params: {
             ...properties,
-            distinct_id: userId
+            distinct_id: userId2
           }
         })
       }
@@ -14607,13 +15026,13 @@ const identifyWithLocation = async (userId, properties, report) => {
     else report("datalake", "failed");
   }
 };
-async function identify(userId, properties = {}) {
+async function identify(userId2, properties = {}) {
   const report = createIdentifyReporter();
   if (!await waitForIdentifyReady(report)) return;
   try {
     try {
       validatorService.parseIdentifyProps(properties);
-      if (!userId) {
+      if (!userId2) {
         report("validation", "invalid_input");
         return;
       }
@@ -14632,7 +15051,7 @@ async function identify(userId, properties = {}) {
     }
     const mappedProps = mapProperties(properties);
     try {
-      mixpanelService.identify(userId, mappedProps, report);
+      mixpanelService.identify(userId2, mappedProps, report);
     } catch {
       report("mixpanel", "failed");
     }
@@ -14652,7 +15071,7 @@ async function identify(userId, properties = {}) {
   } catch {
     report("mixpanel", "failed");
   } finally {
-    void identifyWithLocation(userId, properties, report);
+    void identifyWithLocation(userId2, properties, report);
   }
 }
 z.object({