@mparticle/web-sdk 2.79.1 → 2.79.3

package/dist/mparticle.js

@@ -204,7 +204,7 @@ var mParticle = (function () {
       Base64: Base64$1
     };
 
-    var version = "2.79.1";
+    var version = "2.79.3";
 
     var Constants = {
       sdkVersion: version,
@@ -3866,7 +3866,7 @@ var mParticle = (function () {
         filteredUserIdentities.push(identity);
       }
     }
-    function buildFilteredUserIdentities(userIdentitiesObject, filterList, inArray) {
+    function buildFilteredUserIdentities$1(userIdentitiesObject, filterList, inArray) {
       var filteredUserIdentities = [];
       if (!userIdentitiesObject || !Object.keys(userIdentitiesObject).length) {
         return filteredUserIdentities;
@@ -3988,7 +3988,7 @@ var mParticle = (function () {
         return xhr;
       };
       this.filterUserIdentities = function (userIdentitiesObject, filterList) {
-        return buildFilteredUserIdentities(userIdentitiesObject, filterList, self.inArray);
+        return buildFilteredUserIdentities$1(userIdentitiesObject, filterList, self.inArray);
       };
       this.filterUserIdentitiesForForwarders = KitFilterHelper.filterUserIdentities;
       this.filterUserAttributes = KitFilterHelper.filterUserAttributes;
@@ -4056,6 +4056,15 @@ var mParticle = (function () {
     var Messages$8 = Constants.Messages;
     var androidBridgeNameBase = 'mParticleAndroid';
     var iosBridgeNameBase = 'mParticle';
+    function getAndroidBridge(name) {
+      if (!Object.prototype.hasOwnProperty.call(window, name)) {
+        return undefined;
+      }
+      return window[name];
+    }
+    function getInstanceNamedValue(instance, name) {
+      return instance[name];
+    }
     function NativeSdkHelpers(mpInstance) {
       var self = this;
       this.initializeSessionAttributes = function (apiKey) {
@@ -4074,14 +4083,14 @@ var mParticle = (function () {
         }
       };
       this.isBridgeV2Available = function (bridgeName) {
+        var _a, _b;
         if (!bridgeName) {
           return false;
         }
         var androidBridgeName = androidBridgeNameBase + '_' + bridgeName + '_v2';
         var iosBridgeName = iosBridgeNameBase + '_' + bridgeName + '_v2';
-
         // iOS v2 bridge
-        if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.hasOwnProperty(iosBridgeName)) {
+        if ((_b = (_a = window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b.hasOwnProperty(iosBridgeName)) {
           return true;
         }
         // other iOS v2 bridge
@@ -4101,7 +4110,6 @@ var mParticle = (function () {
         if (minWebviewBridgeVersion === 2) {
           return mpInstance._Store.bridgeV2Available;
         }
-
         // iOS BridgeV1 can be available via mParticle.isIOS, but return false if uiwebviewBridgeName doesn't match requiredWebviewBridgeName
         if (window.mParticle) {
           if (window.mParticle.uiwebviewBridgeName && window.mParticle.uiwebviewBridgeName !== iosBridgeNameBase + '_' + requiredWebviewBridgeName + '_v2') {
@@ -4150,19 +4158,19 @@ var mParticle = (function () {
         iframe.parentNode.removeChild(iframe);
       };
       this.sendViaBridgeV2 = function (path, value, requiredWebviewBridgeName) {
+        var _a, _b;
         if (!requiredWebviewBridgeName) {
           return;
         }
         var androidBridgeName = androidBridgeNameBase + '_' + requiredWebviewBridgeName + '_v2',
-          androidBridge = window[androidBridgeName],
-          iosBridgeName = iosBridgeNameBase + '_' + requiredWebviewBridgeName + '_v2',
-          iOSBridgeMessageHandler,
-          iOSBridgeNonMessageHandler;
-        if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers[iosBridgeName]) {
+          androidBridge = getAndroidBridge(androidBridgeName),
+          iosBridgeName = iosBridgeNameBase + '_' + requiredWebviewBridgeName + '_v2';
+        var iOSBridgeMessageHandler, iOSBridgeNonMessageHandler;
+        if ((_b = (_a = window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b[iosBridgeName]) {
           iOSBridgeMessageHandler = window.webkit.messageHandlers[iosBridgeName];
         }
         if (mpInstance.uiwebviewBridgeName === iosBridgeName) {
-          iOSBridgeNonMessageHandler = mpInstance[iosBridgeName];
+          iOSBridgeNonMessageHandler = getInstanceNamedValue(mpInstance, iosBridgeName);
         }
         if (androidBridge && androidBridge.hasOwnProperty(path)) {
           mpInstance.Logger.verbose(Messages$8.InformationMessages.SendAndroid + path);
@@ -6979,20 +6987,61 @@ var mParticle = (function () {
 
     var _regeneratorRuntime = /*@__PURE__*/getDefaultExportFromCjs(regenerator);
 
+    function isAttributeKeyAllowed(kitBlocker, key) {
+      return !(kitBlocker === null || kitBlocker === void 0 ? void 0 : kitBlocker.isAttributeKeyBlocked(key));
+    }
+    function isIdentityAllowed(kitBlocker, identityName) {
+      return !(kitBlocker === null || kitBlocker === void 0 ? void 0 : kitBlocker.isIdentityBlocked(identityName));
+    }
+    function copyUserAttributeValue(value) {
+      return Array.isArray(value) ? value.slice() : value;
+    }
+    function buildUserAttributesCopy(userAttributes, kitBlocker) {
+      var userAttributesCopy = {};
+      if (!userAttributes) {
+        return userAttributesCopy;
+      }
+      for (var prop in userAttributes) {
+        if (!userAttributes.hasOwnProperty(prop) || !isAttributeKeyAllowed(kitBlocker, prop)) {
+          continue;
+        }
+        userAttributesCopy[prop] = copyUserAttributeValue(userAttributes[prop]);
+      }
+      return userAttributesCopy;
+    }
+    function buildUserAttributeLists(userAttributes, kitBlocker) {
+      var userAttributesLists = {};
+      for (var key in userAttributes) {
+        if (!userAttributes.hasOwnProperty(key) || !Array.isArray(userAttributes[key]) || !isAttributeKeyAllowed(kitBlocker, key)) {
+          continue;
+        }
+        userAttributesLists[key] = userAttributes[key].slice();
+      }
+      return userAttributesLists;
+    }
+    function buildFilteredUserIdentities(identities, kitBlocker, parseNumber) {
+      var currentUserIdentities = {};
+      var identitiesByType = identities;
+      for (var identityType in identitiesByType) {
+        if (!identitiesByType.hasOwnProperty(identityType)) {
+          continue;
+        }
+        var identityName = Types.IdentityType.getIdentityName(parseNumber(identityType));
+        if (!isIdentityAllowed(kitBlocker, identityName)) {
+          continue;
+        }
+        currentUserIdentities[identityName] = identitiesByType[identityType];
+      }
+      return currentUserIdentities;
+    }
     function filteredMparticleUser(mpid, forwarder, mpInstance, kitBlocker) {
-      var self = this;
+      function getAllUserAttributes() {
+        var userAttributesCopy = buildUserAttributesCopy(mpInstance._Store.getUserAttributes(mpid), kitBlocker);
+        return mpInstance._Helpers.filterUserAttributes(userAttributesCopy, forwarder.userAttributeFilters);
+      }
       return {
         getUserIdentities: function getUserIdentities() {
-          var currentUserIdentities = {};
-          var identities = mpInstance._Store.getUserIdentities(mpid);
-          for (var identityType in identities) {
-            if (identities.hasOwnProperty(identityType)) {
-              var identityName = Types.IdentityType.getIdentityName(mpInstance._Helpers.parseNumber(identityType));
-              if (!kitBlocker || kitBlocker && !kitBlocker.isIdentityBlocked(identityName))
-                //if identity type is not blocked
-                currentUserIdentities[identityName] = identities[identityType];
-            }
-          }
+          var currentUserIdentities = buildFilteredUserIdentities(mpInstance._Store.getUserIdentities(mpid), kitBlocker, mpInstance._Helpers.parseNumber);
           currentUserIdentities = mpInstance._Helpers.filterUserIdentitiesForForwarders(currentUserIdentities, forwarder.userIdentityFilters);
           return {
             userIdentities: currentUserIdentities
@@ -7002,38 +7051,10 @@ var mParticle = (function () {
           return mpid;
         },
         getUserAttributesLists: function getUserAttributesLists(forwarder) {
-          var userAttributes,
-            userAttributesLists = {};
-          userAttributes = self.getAllUserAttributes();
-          for (var key in userAttributes) {
-            if (userAttributes.hasOwnProperty(key) && Array.isArray(userAttributes[key])) {
-              if (!kitBlocker || kitBlocker && !kitBlocker.isAttributeKeyBlocked(key)) {
-                userAttributesLists[key] = userAttributes[key].slice();
-              }
-            }
-          }
-          userAttributesLists = mpInstance._Helpers.filterUserAttributes(userAttributesLists, forwarder.userAttributeFilters);
-          return userAttributesLists;
+          var userAttributesLists = buildUserAttributeLists(getAllUserAttributes(), kitBlocker);
+          return mpInstance._Helpers.filterUserAttributes(userAttributesLists, forwarder.userAttributeFilters);
         },
-        getAllUserAttributes: function getAllUserAttributes() {
-          var userAttributesCopy = {};
-          var userAttributes = mpInstance._Store.getUserAttributes(mpid);
-          if (userAttributes) {
-            for (var prop in userAttributes) {
-              if (userAttributes.hasOwnProperty(prop)) {
-                if (!kitBlocker || kitBlocker && !kitBlocker.isAttributeKeyBlocked(prop)) {
-                  if (Array.isArray(userAttributes[prop])) {
-                    userAttributesCopy[prop] = userAttributes[prop].slice();
-                  } else {
-                    userAttributesCopy[prop] = userAttributes[prop];
-                  }
-                }
-              }
-            }
-          }
-          userAttributesCopy = mpInstance._Helpers.filterUserAttributes(userAttributesCopy, forwarder.userAttributeFilters);
-          return userAttributesCopy;
-        }
+        getAllUserAttributes: getAllUserAttributes
       };
     }
 
@@ -7839,7 +7860,7 @@ var mParticle = (function () {
 
     function forwardingStatsUploader(mpInstance) {
       this.startForwardingStatsTimer = function () {
-        mParticle._forwardingStatsTimer = setInterval(function () {
+        window.mParticle._forwardingStatsTimer = setInterval(function () {
           prepareAndSendForwardingStatsBatch();
         }, mpInstance._Store.SDKConfig.forwarderStatsTimeout);
       };
@@ -7859,12 +7880,12 @@ var mParticle = (function () {
             if (uploadsTable.hasOwnProperty(date)) {
               if (uploadsTable[date].uploading === false) {
                 var xhrCallback = function xhrCallback() {
-                  if (xhr.readyState === 4) {
-                    if (xhr.status === 200 || xhr.status === 202) {
-                      mpInstance.Logger.verbose('Successfully sent  ' + xhr.statusText + ' from server');
+                  if (xhr_1.readyState === 4) {
+                    if (xhr_1.status === 200 || xhr_1.status === 202) {
+                      mpInstance.Logger.verbose('Successfully sent  ' + xhr_1.statusText + ' from server');
                       delete uploadsTable[date];
-                    } else if (xhr.status.toString()[0] === '4') {
-                      if (xhr.status !== 429) {
+                    } else if (xhr_1.status.toString()[0] === '4') {
+                      if (xhr_1.status !== 429) {
                         delete uploadsTable[date];
                       }
                     } else {
@@ -7872,10 +7893,10 @@ var mParticle = (function () {
                     }
                   }
                 };
-                var xhr = mpInstance._Helpers.createXHR(xhrCallback);
+                var xhr_1 = mpInstance._Helpers.createXHR(xhrCallback);
                 var forwardingStatsData = uploadsTable[date].data;
                 uploadsTable[date].uploading = true;
-                mpInstance._APIClient.sendBatchForwardingStatsToServer(forwardingStatsData, xhr);
+                mpInstance._APIClient.sendBatchForwardingStatsToServer(forwardingStatsData, xhr_1);
               }
             }
           })(date);
@@ -11172,184 +11193,335 @@ var mParticle = (function () {
       return LoggingDispatcher;
     }();
 
+    var HISTORY_METHODS = ['pushState', 'replaceState'];
     var WRAPPED_MARKER = '__mpApvWrapped__';
-    var PageViewTracker = /** @class */function () {
-      function PageViewTracker(mpInstance) {
-        this.lastPath = null;
-        this.isActive = false;
-        this.originalPushState = null;
-        this.originalReplaceState = null;
-        this.pushStateWrapper = null;
-        this.replaceStateWrapper = null;
-        this.popStateListener = null;
-        this.mpInstance = mpInstance;
-      }
-      PageViewTracker.prototype.isSupportedEnvironment = function () {
-        return typeof window !== 'undefined' && typeof window.history !== 'undefined' && typeof window.history.pushState === 'function' && typeof window.addEventListener === 'function';
+    // All APV state hangs off one window key, and it is the public debugging
+    // contract: `window.__mpApv__` is what you inspect in a console to see whether
+    // tracking is live.
+    //
+    // It lives on `window` rather than in module scope because Next.js re-executes
+    // the SDK bundle on every SPA navigation: module-level state is reset each time,
+    // but `window` persists for the lifetime of the tab.
+    //
+    // One object rather than a key per flag, so resetting is a single reassignment.
+    // Nothing has to be deleted, and there is no ordering in which half the state
+    // survives the reset.
+    var WIN_APV_KEY = '__mpApv__';
+    // ---------------------------------------------------------------------------
+    // Pure helpers. No `this`, no globals, no side effects — callable and assertable
+    // on their own, which is where the interesting rules live.
+    // ---------------------------------------------------------------------------
+    // Dedup keys on pathname only: a query-string- or hash-only change is the same
+    // page and must not fire a view.
+    var isNewPage = function isNewPage(lastPath, candidatePath) {
+      return candidatePath !== lastPath;
+    };
+    var supportsHistoryTracking = function supportsHistoryTracking(win) {
+      return !!win && win.history !== undefined && typeof win.history.pushState === 'function' && typeof win.addEventListener === 'function';
+    };
+    // Mirrors the event shape of the public mParticle.logPageView(), but carries the
+    // path captured when the navigation was accepted rather than the live location.
+    var buildPageViewEvent = function buildPageViewEvent(data) {
+      return {
+        messageType: MessageType$1.PageView,
+        name: 'PageView',
+        data: __assign({}, data),
+        eventType: EventType.Unknown
       };
-      PageViewTracker.prototype.init = function () {
-        this.mpInstance.Logger.verbose('mParticle APV: [init] PageViewTracker Init');
-        if (!this.isSupportedEnvironment()) {
-          this.mpInstance.Logger.verbose('mParticle APV: [init] unsupported environment (no History API), not starting');
-          return;
-        }
-        if (this.isActive) {
-          this.mpInstance.Logger.verbose('mParticle APV: [init] starting (teardown-first for idempotency)');
-          this.teardown();
-        }
-        this.isActive = true;
-        this.lastPath = this.getCurrentKey();
-        this.mpInstance.Logger.verbose("mParticle APV: [init] seeded lastPath: ".concat(this.lastPath));
-        this.patchHistoryMethods();
-        this.addNavigationListeners();
-        this.mpInstance.Logger.verbose('mParticle APV: [init] patched pushState/replaceState + listening for popstate');
+    };
+    // ---------------------------------------------------------------------------
+    // Window-scoped APV state. Every read and write goes through these helpers, so
+    // neither the tracker nor mp-instance touches `window` directly and
+    // `typeof window` is checked in exactly one place.
+    // ---------------------------------------------------------------------------
+    var apvWindow = function apvWindow() {
+      return typeof window === 'undefined' ? null : window;
+    };
+    var freshState = function freshState() {
+      return {
+        initialPageViewFired: false
       };
-      PageViewTracker.prototype.patchHistoryMethods = function () {
-        var self = this;
-        var installed = window.history.pushState;
-        if (installed[WRAPPED_MARKER]) {
-          this.mpInstance.Logger.verbose('mParticle APV: [patch] history already wrapped, skipping to avoid double-wrap');
-          return;
-        }
-        var originalPushState = window.history.pushState;
-        var originalReplaceState = window.history.replaceState;
-        this.originalPushState = originalPushState;
-        this.originalReplaceState = originalReplaceState;
-        var pushStateWrapper = function pushStateWrapper() {
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-          }
-          var result = originalPushState.apply(this, args);
-          self.safeHandleNavigation('pushState');
-          return result;
-        };
-        var replaceStateWrapper = function replaceStateWrapper() {
+    };
+    // Reads tolerate absent state, so a read never mutates `window`. Only the
+    // writers below create it.
+    var readState = function readState() {
+      var win = apvWindow();
+      return win ? win[WIN_APV_KEY] : undefined;
+    };
+    var writeState = function writeState() {
+      var win = apvWindow();
+      if (!win) {
+        return null;
+      }
+      if (!win[WIN_APV_KEY]) {
+        win[WIN_APV_KEY] = freshState();
+      }
+      return win[WIN_APV_KEY];
+    };
+    var getActiveTracker = function getActiveTracker() {
+      var state = readState();
+      return state ? state.tracker : undefined;
+    };
+    var hasInitialPageViewFired = function hasInitialPageViewFired() {
+      var state = readState();
+      return !!(state && state.initialPageViewFired);
+    };
+    var markInitialPageViewFired = function markInitialPageViewFired() {
+      var state = writeState();
+      if (state) {
+        state.initialPageViewFired = true;
+      }
+    };
+    // Returns the page to its pre-APV state: stops the active tracker (restoring the
+    // history methods it patched), then swaps in fresh state. The state object is the
+    // authoritative handle, so this reaches trackers whose owning module is gone.
+    var resetPageViewTracking = function resetPageViewTracking() {
+      var win = apvWindow();
+      if (!win) {
+        return;
+      }
+      var active = getActiveTracker();
+      if (active) {
+        active.teardown();
+      }
+      // One reassignment replaces every flag at once, so nothing can be left behind
+      // whatever shape the previous state was in.
+      win[WIN_APV_KEY] = freshState();
+    };
+    var setActiveTracker = function setActiveTracker(tracker) {
+      var state = writeState();
+      if (state) {
+        state.tracker = tracker;
+      }
+    };
+    var clearActiveTracker = function clearActiveTracker(tracker) {
+      var state = readState();
+      if (state && state.tracker === tracker) {
+        state.tracker = undefined;
+      }
+    };
+    var currentPathname = function currentPathname() {
+      return window.location.pathname;
+    };
+    // ---------------------------------------------------------------------------
+    // History patching
+    // ---------------------------------------------------------------------------
+    // Wraps pushState/replaceState so `onNavigate` runs after the real method, and
+    // returns the single function that undoes it — or null when nothing was
+    // installed (history is already wrapped, or a frozen/sealed History rejected the
+    // assignment). Handing back one undo closure keeps the wrapper and original
+    // references out of the tracker entirely: there is no half-patched state for a
+    // caller to inspect, and no way to restore the wrong pair.
+    var patchHistory = function patchHistory(onNavigate, log) {
+      if (window.history.pushState[WRAPPED_MARKER]) {
+        log('[patch] history already wrapped, skipping to avoid double-wrap — STACKED WRAPPER DETECTED');
+        return null;
+      }
+      var originals = {};
+      var wrappers = {};
+      HISTORY_METHODS.forEach(function (name) {
+        var original = window.history[name];
+        originals[name] = original;
+        var wrapper = function wrapper() {
           var args = [];
           for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
           }
-          var result = originalReplaceState.apply(this, args);
-          self.safeHandleNavigation('replaceState');
+          var result = original.apply(this, args);
+          onNavigate(name);
           return result;
         };
-        Object.defineProperty(pushStateWrapper, WRAPPED_MARKER, {
+        Object.defineProperty(wrapper, WRAPPED_MARKER, {
           value: true,
           enumerable: false
         });
-        Object.defineProperty(replaceStateWrapper, WRAPPED_MARKER, {
-          value: true,
-          enumerable: false
+        wrappers[name] = wrapper;
+      });
+      // Restore per method: a third party may have patched one of the two on top of
+      // ours after we installed. Clobbering theirs would break their tracking, so
+      // leave anything that is no longer ours in place.
+      var restore = function restore() {
+        return HISTORY_METHODS.forEach(function (name) {
+          if (window.history[name] === wrappers[name]) {
+            window.history[name] = originals[name];
+            log("[teardown] restored original ".concat(name));
+          } else {
+            log("[teardown] ".concat(name, " no longer ours; leaving in place, gating callback to no-op"));
+          }
+        });
+      };
+      try {
+        HISTORY_METHODS.forEach(function (name) {
+          window.history[name] = wrappers[name];
         });
-        this.pushStateWrapper = pushStateWrapper;
-        this.replaceStateWrapper = replaceStateWrapper;
+      } catch (e) {
+        log("[error] failed to patch history methods (frozen/sealed), rolling back: ".concat(e));
         try {
-          window.history.pushState = pushStateWrapper;
-          window.history.replaceState = replaceStateWrapper;
-        } catch (e) {
-          this.mpInstance.Logger.verbose("mParticle APV: [error] failed to patch history methods (frozen/sealed), rolling back: ".concat(e));
-          try {
-            if (window.history.pushState === pushStateWrapper) {
-              window.history.pushState = originalPushState;
-            }
-            if (window.history.replaceState === replaceStateWrapper) {
-              window.history.replaceState = originalReplaceState;
-            }
-          } catch (restoreError) {
-            this.mpInstance.Logger.verbose("mParticle APV: [error] failed to restore history methods after patch failure: ".concat(restoreError));
-          }
-          this.pushStateWrapper = null;
-          this.replaceStateWrapper = null;
-          this.originalPushState = null;
-          this.originalReplaceState = null;
+          restore();
+        } catch (restoreError) {
+          log("[error] failed to restore history methods after patch failure: ".concat(restoreError));
         }
-      };
-      PageViewTracker.prototype.addNavigationListeners = function () {
+        return null;
+      }
+      return restore;
+    };
+    // ---------------------------------------------------------------------------
+    // Tracker
+    // ---------------------------------------------------------------------------
+    var PageViewTracker = /** @class */function () {
+      function PageViewTracker(mpInstance) {
+        this.lastPath = null;
+        this.active = false;
+        this.pendingNavigations = [];
+        this.undoHistoryPatch = null;
+        this.popStateListener = null;
+        this.mpInstance = mpInstance;
+      }
+      Object.defineProperty(PageViewTracker.prototype, "isActive", {
+        // True while this tracker owns the history patch and is listening for
+        // navigations. Flips to false on teardown, including the teardown a
+        // successor tracker performs during a handoff. Read-only, and the one thing
+        // worth checking on `window.__mpApv__.tracker` from a console.
+        get: function get() {
+          return this.active;
+        },
+        enumerable: false,
+        configurable: true
+      });
+      PageViewTracker.prototype.init = function () {
         var _this = this;
+        this.log('[init] PageViewTracker Init');
+        if (!supportsHistoryTracking(apvWindow())) {
+          this.log('[init] unsupported environment (no History API), not starting');
+          return;
+        }
+        // Take over from whichever tracker is currently active: one left behind by
+        // a previous module load, or this same tracker on a repeat
+        // mParticle.init(). Their pending navigations are transferred rather than
+        // dropped — a route change may have queued a deferred fire that has not
+        // flushed yet, and dropping it loses a page view entirely.
+        var active = getActiveTracker();
+        var inheritedPaths = this.retire(active);
+        if (this.active && active !== this) {
+          inheritedPaths = inheritedPaths.concat(this.retire(this));
+        }
+        this.active = true;
+        this.lastPath = currentPathname();
+        this.log("[init] seeded lastPath: ".concat(this.lastPath));
+        this.undoHistoryPatch = patchHistory(function (source) {
+          return _this.safeHandleNavigation(source);
+        }, function (message) {
+          return _this.log(message);
+        });
         this.popStateListener = function () {
           return _this.safeHandleNavigation('popstate');
         };
         window.addEventListener('popstate', this.popStateListener);
+        setActiveTracker(this);
+        this.log('[init] patched pushState/replaceState + listening for popstate');
+        inheritedPaths.forEach(function (path) {
+          return _this.scheduleFire(path);
+        });
+      };
+      PageViewTracker.prototype.teardown = function () {
+        // Discard pending deferred fires (e.g. AutoLogPageView switched off on
+        // re-init). A handoff calls takePendingNavigations() first, so by this
+        // point those paths are already transferred rather than dropped.
+        this.takePendingNavigations();
+        if (this.popStateListener) {
+          window.removeEventListener('popstate', this.popStateListener);
+          this.popStateListener = null;
+        }
+        if (this.undoHistoryPatch) {
+          this.undoHistoryPatch();
+          this.undoHistoryPatch = null;
+        }
+        this.active = false;
+        clearActiveTracker(this);
+      };
+      // Stops the outgoing tracker and returns the paths it had queued so this
+      // tracker can re-schedule them once it is active. Private, but reachable
+      // across instances: the handoff protocol stays internal to the class.
+      PageViewTracker.prototype.retire = function (outgoing) {
+        if (!outgoing) {
+          return [];
+        }
+        this.log(outgoing === this ? '[init] retiring this tracker for a repeat mParticle.init() — transferring pending navigations and tearing down' : '[init] retiring a tracker from a previous module load — transferring pending navigations and tearing down');
+        var paths = outgoing.takePendingNavigations();
+        outgoing.teardown();
+        return paths;
+      };
+      // Cancels this tracker's deferred fires and hands back their captured paths.
+      PageViewTracker.prototype.takePendingNavigations = function () {
+        var pending = this.pendingNavigations;
+        this.pendingNavigations = [];
+        pending.forEach(function (p) {
+          return clearTimeout(p.timeoutId);
+        });
+        return pending.map(function (p) {
+          return p.path;
+        });
       };
       PageViewTracker.prototype.safeHandleNavigation = function (source) {
+        // An orphaned wrapper still calls in: teardown can only restore a history
+        // method that is still ours, so one a third party patched over stays
+        // installed and keeps firing at a dead tracker. Bail before touching
+        // lastPath or queueing a fire the flush would just abort. Guarding here
+        // rather than at each wrapper also covers the popstate path.
+        if (!this.active) {
+          return;
+        }
         try {
           this.handleNavigation(source);
         } catch (e) {
-          this.mpInstance.Logger.verbose("mParticle APV: [error] navigation handler threw (".concat(source, "), page view skipped: ").concat(e));
+          this.log("[error] navigation handler threw (".concat(source, "), page view skipped: ").concat(e));
         }
       };
-      PageViewTracker.prototype.getCurrentKey = function () {
-        return window.location.pathname;
-      };
       PageViewTracker.prototype.handleNavigation = function (source) {
-        var _this = this;
-        var candidatePath = this.getCurrentKey();
-        this.mpInstance.Logger.verbose("mParticle APV: [detect] navigation signal (source: ".concat(source, ", candidatePath: ").concat(candidatePath, ", lastPath: ").concat(this.lastPath, ")"));
-        if (candidatePath === this.lastPath) {
-          this.mpInstance.Logger.verbose("mParticle APV: [dedupe] pathname unchanged, skipping (source: ".concat(source, ", path: ").concat(candidatePath, ")"));
+        var candidatePath = currentPathname();
+        this.log("[detect] navigation signal (source: ".concat(source, ", candidatePath: ").concat(candidatePath, ", lastPath: ").concat(this.lastPath, ")"));
+        if (!isNewPage(this.lastPath, candidatePath)) {
+          this.log("[dedupe] pathname unchanged, skipping (source: ".concat(source, ", path: ").concat(candidatePath, ")"));
           return;
         }
-        this.mpInstance.Logger.verbose("mParticle APV: [accept] pathname changed, scheduling fire (source: ".concat(source, ", from: ").concat(this.lastPath, ", to: ").concat(candidatePath, ")"));
+        this.log("[accept] pathname changed, scheduling fire (source: ".concat(source, ", from: ").concat(this.lastPath, ", to: ").concat(candidatePath, ")"));
         this.lastPath = candidatePath;
-        // Snapshot the path now: it is already settled at this point, and a
-        // same-tick navigation would otherwise overwrite window.location
-        // before the deferred flush reads it. The title is intentionally read
-        // later (in the deferred flush) so the router's post-navigation render
-        // commit has a chance to update document.title first.
-        var capturedPath = candidatePath;
-        setTimeout(function () {
-          if (!_this.isActive) {
-            _this.mpInstance.Logger.verbose('mParticle APV: [defer] fire aborted, tracker inactive (torn down before flush)');
+        this.scheduleFire(candidatePath);
+      };
+      // Deferred by a macrotask so the router's post-navigation render commit has a
+      // chance to update document.title before the event is built. The path is
+      // snapshotted now because it is already settled, whereas a same-tick
+      // navigation would overwrite window.location before the flush reads it.
+      PageViewTracker.prototype.scheduleFire = function (path) {
+        var _this = this;
+        var timeoutId = setTimeout(function () {
+          _this.pendingNavigations = _this.pendingNavigations.filter(function (p) {
+            return p.timeoutId !== timeoutId;
+          });
+          if (!_this.active) {
+            _this.log('[defer] fire aborted, tracker inactive (torn down before flush)');
             return;
           }
           _this.mpInstance._SessionManager.resetSessionTimer();
-          _this.firePageView(capturedPath);
+          _this.firePageView(path);
         }, 0);
+        this.pendingNavigations.push({
+          path: path,
+          timeoutId: timeoutId
+        });
       };
-      // Mirrors the event shape of the public mParticle.logPageView(), but carries
-      // the captured SPA path rather than reading the live location.
       PageViewTracker.prototype.firePageView = function (path) {
         var title = window.document.title;
-        this.mpInstance.Logger.verbose("mParticle APV: [fire] deferred flush -> _Events.logEvent(PageView) (path: ".concat(path, ", title: ").concat(title, ")"));
-        this.mpInstance._Events.logEvent({
-          messageType: MessageType$1.PageView,
-          name: 'PageView',
-          data: {
-            hostname: window.location.hostname,
-            title: title,
-            path: path
-          },
-          eventType: EventType.Unknown
+        var event = buildPageViewEvent({
+          hostname: window.location.hostname,
+          title: title,
+          path: path
         });
+        this.log("[fire] deferred flush -> _Events.logEvent(PageView) (path: ".concat(path, ", title: ").concat(title, ")"));
+        this.mpInstance._Events.logEvent(event);
       };
-      PageViewTracker.prototype.teardown = function () {
-        if (this.popStateListener) {
-          window.removeEventListener('popstate', this.popStateListener);
-          this.popStateListener = null;
-        }
-        var pushStateStillOurs = this.pushStateWrapper !== null && window.history.pushState === this.pushStateWrapper;
-        if (this.originalPushState) {
-          if (pushStateStillOurs) {
-            window.history.pushState = this.originalPushState;
-            this.mpInstance.Logger.verbose('mParticle APV: [teardown] restored original pushState');
-          } else {
-            this.mpInstance.Logger.verbose('mParticle APV: [teardown] pushState no longer ours; leaving in place, gating callback to no-op');
-          }
-          this.originalPushState = null;
-          this.pushStateWrapper = null;
-        }
-        var replaceStateStillOurs = this.replaceStateWrapper !== null && window.history.replaceState === this.replaceStateWrapper;
-        if (this.originalReplaceState) {
-          if (replaceStateStillOurs) {
-            window.history.replaceState = this.originalReplaceState;
-            this.mpInstance.Logger.verbose('mParticle APV: [teardown] restored original replaceState');
-          } else {
-            this.mpInstance.Logger.verbose('mParticle APV: [teardown] replaceState no longer ours; leaving in place, gating callback to no-op');
-          }
-          this.originalReplaceState = null;
-          this.replaceStateWrapper = null;
-        }
-        this.isActive = false;
+      PageViewTracker.prototype.log = function (message) {
+        this.mpInstance.Logger.verbose("mParticle APV: ".concat(message));
       };
       return PageViewTracker;
     }();
@@ -11506,6 +11678,8 @@ var mParticle = (function () {
         instance._Store = new Store(config, instance);
         instance._Store.isLocalStorageAvailable = instance._Persistence.determineLocalStorageAvailability(window.localStorage);
         instance._Events.stopTracking();
+        resetPageViewTracking();
+        instance._PageViewTracker = undefined;
         if (!keepPersistence) {
           instance._Persistence.resetPersistence();
         }
@@ -12432,13 +12606,28 @@ var mParticle = (function () {
         // Logs a session start or session end event accordingly
         mpInstance._SessionManager.initialize();
         mpInstance._Events.logAST();
+        // Note: APV state (the active tracker and the initial-page-view flag) is
+        // window-scoped and assumes a single active SDK instance. Multiple-instance
+        // support is out of scope.
         if (getFeatureFlag(AutoLogPageView)) {
-          mpInstance._Events.logPageView();
           if (!mpInstance._PageViewTracker) {
+            mpInstance.Logger.verbose('mParticle APV: [sdk-init] creating new PageViewTracker for this instance');
             mpInstance._PageViewTracker = new PageViewTracker(mpInstance);
           }
+          // The initial page view fires once per hard page load, not once per
+          // init(): the window flag survives the module re-evaluation Next.js
+          // performs on every SPA navigation, so repeated init() calls from SPA
+          // re-renders don't fire duplicate logPageView() events.
+          if (hasInitialPageViewFired()) {
+            mpInstance.Logger.verbose('mParticle APV: [sdk-init] initial page view already logged this page load, skipping');
+          } else {
+            markInitialPageViewFired();
+            mpInstance._Events.logPageView();
+          }
           mpInstance._PageViewTracker.init();
         } else if (mpInstance._PageViewTracker) {
+          // AutoLogPageView was disabled on re-init: tear down the active tracker
+          // so it stops listening. Re-created if the flag is re-enabled later.
           mpInstance._PageViewTracker.teardown();
         }
         processIdentityCallback(mpInstance, currentUser, currentUserMPID, currentUserIdentities);