@reservamos/browser-analytics 1.1.8-alpha.0 → 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,28 +13471,63 @@ function observeIdentifyResult(stage, report, onTimeout) {
   }, 5e3);
   return { complete };
 }
-const version = "1.1.8-alpha.0";
+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);
-  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");
   if (!report) {
     mixpanel.people.set(properties);
     return;
@@ -13478,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()) {
@@ -13509,7 +13588,9 @@ function updateCachedDistinctId(distinctId) {
 }
 const mixpanelService = {
   init: init$2,
+  validateConfiguration,
   isReady,
+  onReady: onReady$1,
   track,
   identify: identify$1,
   attachProperty,
@@ -13520,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(
@@ -13565,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: {
@@ -13577,19 +13671,20 @@ 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);
@@ -13605,8 +13700,8 @@ 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 (!isFingerprintReady()) {
@@ -13617,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 {
@@ -13652,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;
@@ -13792,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"),
@@ -13806,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(),
@@ -14071,6 +14325,7 @@ const validatorService = {
   parseIdentifyProps,
   validateProps
 };
+let initialization = 0;
 function onLoaded() {
   window.dispatchEvent(new CustomEvent("Tracker Ready"));
 }
@@ -14085,19 +14340,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 +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",
@@ -14377,15 +14657,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 +14688,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 +14797,6 @@ async function submitEvent(eventName, eventProperties, meta) {
     const defaultProperties = {
       "User Fingerprint": fingerprint
     };
-    const trackingParams = extractTrackingParams();
     const simplifiedData = flattenEventData(eventProperties);
     const properties = {
       ...defaultProperties,
@@ -14458,28 +14805,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() {
@@ -14616,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 {
@@ -14653,7 +15012,7 @@ const identifyWithLocation = async (userId, properties, report) => {
         body: JSON.stringify({
           profile_params: {
             ...properties,
-            distinct_id: userId
+            distinct_id: userId2
           }
         })
       }
@@ -14667,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;
       }
@@ -14692,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");
     }
@@ -14712,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({