@mparticle/web-sdk 2.57.0 → 2.59.0

package/dist/mparticle.js

@@ -203,7 +203,7 @@ var mParticle = (function () {
       Base64: Base64$1
     };
 
-    var version = "2.57.0";
+    var version = "2.59.0";
 
     var Constants = {
       sdkVersion: version,
@@ -328,7 +328,9 @@ var mParticle = (function () {
         configUrl: 'jssdkcdns.mparticle.com/JS/v2/',
         identityUrl: 'identity.mparticle.com/v1/',
         aliasUrl: 'jssdks.mparticle.com/v1/identity/',
-        userAudienceUrl: 'nativesdks.mparticle.com/v1/'
+        userAudienceUrl: 'nativesdks.mparticle.com/v1/',
+        loggingUrl: 'apps.rokt-api.com/v1/log',
+        errorUrl: 'apps.rokt-api.com/v1/errors'
       },
       // These are the paths that are used to construct the CNAME urls
       CNAMEUrlPaths: {
@@ -337,7 +339,9 @@ var mParticle = (function () {
         v3SecureServiceUrl: '/webevents/v3/JS/',
         configUrl: '/tags/JS/v2/',
         identityUrl: '/identity/v1/',
-        aliasUrl: '/webevents/v1/identity/'
+        aliasUrl: '/webevents/v1/identity/',
+        loggingUrl: '/v1/log',
+        errorUrl: '/v1/errors'
       },
       Base64CookieKeys: {
         csm: 1,
@@ -2208,6 +2212,26 @@ var mParticle = (function () {
       }
       return SessionStorageVault;
     }(BaseVault);
+    // DisabledVault is used when persistence is disabled by privacy flags.
+    var DisabledVault = /** @class */function (_super) {
+      __extends(DisabledVault, _super);
+      function DisabledVault(storageKey, options) {
+        var _this = _super.call(this, storageKey, window.localStorage, options) || this;
+        _this.contents = null;
+        _this.storageObject.removeItem(_this._storageKey);
+        return _this;
+      }
+      DisabledVault.prototype.store = function (_item) {
+        this.contents = null;
+      };
+      DisabledVault.prototype.retrieve = function () {
+        return this.contents;
+      };
+      DisabledVault.prototype.purge = function () {
+        this.contents = null;
+      };
+      return DisabledVault;
+    }(BaseVault);
 
     var AsyncUploader = /** @class */function () {
       function AsyncUploader(url) {
@@ -2370,6 +2394,7 @@ var mParticle = (function () {
        */
       function BatchUploader(mpInstance, uploadInterval) {
         var _a;
+        var _b;
         this.offlineStorageEnabled = false;
         this.lastASTEventTime = 0;
         this.AST_DEBOUNCE_MS = 1000; // 1 second debounce
@@ -2388,7 +2413,9 @@ var mParticle = (function () {
         // Cache Offline Storage Availability boolean
         // so that we don't have to check it every time
         this.offlineStorageEnabled = this.isOfflineStorageAvailable();
-        if (this.offlineStorageEnabled) {
+        // When noFunctional is true, prevent events/batches storage
+        var noFunctional = (_b = mpInstance._CookieConsentManager) === null || _b === void 0 ? void 0 : _b.getNoFunctional();
+        if (this.offlineStorageEnabled && !noFunctional) {
           this.eventVault = new SessionStorageVault("".concat(mpInstance._Store.storageName, "-events"), {
             logger: mpInstance.Logger
           });
@@ -2398,9 +2425,9 @@ var mParticle = (function () {
           // Load Events from Session Storage in case we have any in storage
           (_a = this.eventsQueuedForProcessing).push.apply(_a, this.eventVault.retrieve());
         }
-        var _b = this.mpInstance._Store,
-          SDKConfig = _b.SDKConfig,
-          devToken = _b.devToken;
+        var _c = this.mpInstance._Store,
+          SDKConfig = _c.SDKConfig,
+          devToken = _c.devToken;
         var baseUrl = this.mpInstance._Helpers.createServiceUrl(SDKConfig.v3SecureServiceUrl, devToken);
         this.uploadUrl = "".concat(baseUrl, "/events");
         this.uploader = window.fetch ? new FetchUploader(this.uploadUrl) : new XHRUploader(this.uploadUrl);
@@ -2763,6 +2790,181 @@ var mParticle = (function () {
       return BatchUploader;
     }();
 
+    var _a = Constants.IdentityMethods,
+      Identify$2 = _a.Identify,
+      Modify$4 = _a.Modify,
+      Login$2 = _a.Login,
+      Logout$2 = _a.Logout;
+    var CACHE_HEADER = 'x-mp-max-age';
+    var cacheOrClearIdCache = function cacheOrClearIdCache(method, knownIdentities, idCache, identityResponse, parsingCachedResponse) {
+      // when parsing a response that has already been cached, simply return instead of attempting another cache
+      if (parsingCachedResponse) {
+        return;
+      }
+      // default the expire timestamp to one day in milliseconds unless a header comes back
+      var expireTimestamp = getExpireTimestamp(identityResponse === null || identityResponse === void 0 ? void 0 : identityResponse.cacheMaxAge);
+      switch (method) {
+        case Login$2:
+        case Identify$2:
+          cacheIdentityRequest(method, knownIdentities, expireTimestamp, idCache, identityResponse);
+          break;
+        case Modify$4:
+        case Logout$2:
+          idCache.purge();
+          break;
+      }
+    };
+    var cacheIdentityRequest = function cacheIdentityRequest(method, identities, expireTimestamp, idCache, identityResponse) {
+      var responseText = identityResponse.responseText,
+        status = identityResponse.status;
+      var cache = idCache.retrieve() || {};
+      var cacheKey = concatenateIdentities(method, identities);
+      var hashedKey = generateHash(cacheKey);
+      var mpid = responseText.mpid,
+        is_logged_in = responseText.is_logged_in;
+      var cachedResponseBody = {
+        mpid: mpid,
+        is_logged_in: is_logged_in
+      };
+      cache[hashedKey] = {
+        responseText: JSON.stringify(cachedResponseBody),
+        status: status,
+        expireTimestamp: expireTimestamp
+      };
+      idCache.store(cache);
+    };
+    // We need to ensure that identities are concatenated in a deterministic way, so
+    // we sort the identities based on their enum.
+    // we create an array, set the user identity at the index of the user identity type
+    var concatenateIdentities = function concatenateIdentities(method, userIdentities) {
+      var DEVICE_APPLICATION_STAMP = 'device_application_stamp';
+      // set DAS first since it is not an official identity type
+      var cacheKey = "".concat(method, ":").concat(DEVICE_APPLICATION_STAMP, "=").concat(userIdentities.device_application_stamp, ";");
+      var idLength = Object.keys(userIdentities).length;
+      var concatenatedIdentities = '';
+      if (idLength) {
+        var userIDArray = new Array();
+        // create an array where each index is equal to the user identity type
+        for (var key in userIdentities) {
+          if (key === DEVICE_APPLICATION_STAMP) {
+            continue;
+          } else {
+            userIDArray[Types.IdentityType.getIdentityType(key)] = userIdentities[key];
+          }
+        }
+        concatenatedIdentities = userIDArray.reduce(function (prevValue, currentValue, index) {
+          var idName = Types.IdentityType.getIdentityName(index);
+          return "".concat(prevValue).concat(idName, "=").concat(currentValue, ";");
+        }, cacheKey);
+      }
+      return concatenatedIdentities;
+    };
+    var hasValidCachedIdentity = function hasValidCachedIdentity(method, proposedUserIdentities, idCache) {
+      // There is an edge case where multiple identity calls are taking place
+      // before identify fires, so there may not be a cache.  See what happens when
+      // the ? in idCache is removed to the following test
+      // "queued events contain login mpid instead of identify mpid when calling
+      // login immediately after mParticle initializes"
+      var cache = idCache === null || idCache === void 0 ? void 0 : idCache.retrieve();
+      // if there is no cache, then there is no valid cached identity
+      if (!cache) {
+        return false;
+      }
+      var cacheKey = concatenateIdentities(method, proposedUserIdentities);
+      var hashedKey = generateHash(cacheKey);
+      // if cache doesn't have the cacheKey, there is no valid cached identity
+      if (!cache.hasOwnProperty(hashedKey)) {
+        return false;
+      }
+      // If there is a valid cache key, compare the expireTimestamp to the current time.
+      // If the current time is greater than the expireTimestamp, it is not a valid
+      // cached identity.
+      var expireTimestamp = cache[hashedKey].expireTimestamp;
+      if (expireTimestamp < new Date().getTime()) {
+        return false;
+      } else {
+        return true;
+      }
+    };
+    var getCachedIdentity = function getCachedIdentity(method, proposedUserIdentities, idCache) {
+      var cacheKey = concatenateIdentities(method, proposedUserIdentities);
+      var hashedKey = generateHash(cacheKey);
+      var cache = idCache.retrieve();
+      var cachedIdentity = cache ? cache[hashedKey] : null;
+      return {
+        responseText: parseIdentityResponse(cachedIdentity.responseText),
+        expireTimestamp: cachedIdentity.expireTimestamp,
+        status: cachedIdentity.status
+      };
+    };
+    // https://go.mparticle.com/work/SQDSDKS-6079
+    var createKnownIdentities = function createKnownIdentities(identityApiData, deviceId) {
+      var identitiesResult = {};
+      if (isObject(identityApiData === null || identityApiData === void 0 ? void 0 : identityApiData.userIdentities)) {
+        for (var identity in identityApiData.userIdentities) {
+          identitiesResult[identity] = identityApiData.userIdentities[identity];
+        }
+      }
+      identitiesResult.device_application_stamp = deviceId;
+      return identitiesResult;
+    };
+    var removeExpiredIdentityCacheDates = function removeExpiredIdentityCacheDates(idCache) {
+      var cache = idCache.retrieve() || {};
+      var currentTime = new Date().getTime();
+      // Iterate over the cache and remove any key/value pairs that are expired
+      for (var key in cache) {
+        if (cache[key].expireTimestamp < currentTime) {
+          delete cache[key];
+        }
+      }
+      idCache.store(cache);
+    };
+    var tryCacheIdentity = function tryCacheIdentity(knownIdentities, idCache, parseIdentityResponse, mpid, callback, identityApiData, identityMethod) {
+      // https://go.mparticle.com/work/SQDSDKS-6095
+      var shouldReturnCachedIdentity = hasValidCachedIdentity(identityMethod, knownIdentities, idCache);
+      // If Identity is cached, then immediately parse the identity response
+      if (shouldReturnCachedIdentity) {
+        var cachedIdentity = getCachedIdentity(identityMethod, knownIdentities, idCache);
+        parseIdentityResponse(cachedIdentity, mpid, callback, identityApiData, identityMethod, knownIdentities, true);
+        return true;
+      }
+      return false;
+    };
+    var getExpireTimestamp = function getExpireTimestamp(maxAge) {
+      if (maxAge === void 0) {
+        maxAge = ONE_DAY_IN_SECONDS;
+      }
+      return new Date().getTime() + maxAge * MILLIS_IN_ONE_SEC;
+    };
+    var parseIdentityResponse = function parseIdentityResponse(responseText) {
+      return responseText ? JSON.parse(responseText) : {};
+    };
+    var hasIdentityRequestChanged = function hasIdentityRequestChanged(currentUser, newIdentityRequest) {
+      if (!currentUser || !(newIdentityRequest === null || newIdentityRequest === void 0 ? void 0 : newIdentityRequest.userIdentities)) {
+        return false;
+      }
+      var currentUserIdentities = currentUser.getUserIdentities().userIdentities;
+      var newIdentities = newIdentityRequest.userIdentities;
+      return JSON.stringify(currentUserIdentities) !== JSON.stringify(newIdentities);
+    };
+    /**
+     * Checks if deviceId or other user identifiers (like email) were explicitly provided
+     * by the partner via config.deviceId or config.identifyRequest.userIdentities.
+     * When noFunctional is true, then cookies are blocked, so the partner must explicitly
+     * pass deviceId or other identifiers to prevent new users from being created on each page load.
+     *
+     * @param store - The SDK store (provides SDKConfig.deviceId and SDKConfig.identifyRequest.userIdentities)
+     * @returns true if deviceId or other identifiers were explicitly provided in config, false otherwise
+     */
+    var hasExplicitIdentifier = function hasExplicitIdentifier(store) {
+      var _a, _b, _c;
+      var userIdentities = (_b = (_a = store === null || store === void 0 ? void 0 : store.SDKConfig) === null || _a === void 0 ? void 0 : _a.identifyRequest) === null || _b === void 0 ? void 0 : _b.userIdentities;
+      if (userIdentities && isObject(userIdentities) && !isEmpty(userIdentities) && Object.values(userIdentities).some(Boolean)) {
+        return true;
+      }
+      return !!((_c = store === null || store === void 0 ? void 0 : store.SDKConfig) === null || _c === void 0 ? void 0 : _c.deviceId);
+    };
+
     function APIClient(mpInstance, kitBlocker) {
       this.uploader = null;
       var self = this;
@@ -2798,6 +3000,28 @@ var mParticle = (function () {
           }
         });
       };
+      // When noFunctional is set and there are no identities passed, the SDK will not fully initialize.
+      // In this case, there will be no MPID, but we still want kits to initialize and forward the event to kits.
+      // The original event is queued for the MP server upload path so it can be sent once an MPID is returned.
+      // Returns true if the event was handled by this path (caller should return early).
+      var handleNoFunctionalPreMpidEvent = function handleNoFunctionalPreMpidEvent(event, mpid) {
+        var _a;
+        var noFunctionalWithoutId = ((_a = mpInstance._CookieConsentManager) === null || _a === void 0 ? void 0 : _a.getNoFunctional()) && !hasExplicitIdentifier(mpInstance._Store);
+        if (!noFunctionalWithoutId || mpid || !mpInstance._Store.configurationLoaded || mpInstance._Store.requireDelay) {
+          return false;
+        }
+        var forwarderEvent = event;
+        if (kitBlocker === null || kitBlocker === void 0 ? void 0 : kitBlocker.kitBlockingEnabled) {
+          forwarderEvent = kitBlocker.createBlockedEvent(event);
+        }
+        if (forwarderEvent) {
+          mpInstance._Forwarders.sendEventToForwarders(forwarderEvent);
+          event.AlreadySentToForwarders = true;
+        }
+        mpInstance.Logger.verbose('noFunctional event forwarded to kits and queued for MP server upload when MPID is available.');
+        mpInstance._Store.eventQueue.push(event);
+        return true;
+      };
       this.sendEventToServer = function (event, _options) {
         var defaultOptions = {
           shouldUploadEvent: true
@@ -2813,8 +3037,12 @@ var mParticle = (function () {
           mpid = currentUser.getMPID();
         }
         mpInstance._Store.requireDelay = mpInstance._Helpers.isDelayedByIntegration(mpInstance._preInit.integrationDelays, mpInstance._Store.integrationDelayTimeoutStart, Date.now());
-        // We queue events if there is no MPID (MPID is null, or === 0), or there are integrations that that require this to stall because integration attributes
-        // need to be set, or if we are still fetching the config (self hosted only), and so require delaying events
+        if (handleNoFunctionalPreMpidEvent(event, mpid)) {
+          return;
+        }
+        // We queue events if there is no MPID (MPID is null, or === 0), or there are integrations that
+        // require this to stall because integration attributes need to be set, or if we are still
+        // fetching the config (self hosted only), and so require delaying events
         if (!mpid || mpInstance._Store.requireDelay || !mpInstance._Store.configurationLoaded) {
           mpInstance.Logger.verbose('Event was added to eventQueue. eventQueue will be processed once a valid MPID is returned or there is no more integration imposed delay.');
           mpInstance._Store.eventQueue.push(event);
@@ -2836,8 +3064,10 @@ var mParticle = (function () {
             event = kitBlocker.createBlockedEvent(event);
           }
           // We need to check event again, because kitblocking
-          // can nullify the event
-          if (event) {
+          // can nullify the event.
+          // Skip if forwarders were already called in the noFunctional pre-MPID path
+          // to prevent double-sending when the event queue is later flushed.
+          if (event && !event.AlreadySentToForwarders) {
             mpInstance._Forwarders.sendEventToForwarders(event);
           }
         }
@@ -2896,7 +3126,7 @@ var mParticle = (function () {
       };
     }
 
-    var Modify$4 = Constants.IdentityMethods.Modify;
+    var Modify$3 = Constants.IdentityMethods.Modify;
     var Validators = {
       // From ./utils
       // Utility Functions for backwards compatability
@@ -2936,7 +3166,7 @@ var mParticle = (function () {
           copyUserAttributes: 1
         };
         if (identityApiData) {
-          if (method === Modify$4) {
+          if (method === Modify$3) {
             if (isObject(identityApiData.userIdentities) && !Object.keys(identityApiData.userIdentities).length || !isObject(identityApiData.userIdentities)) {
               return {
                 valid: false,
@@ -3502,12 +3732,18 @@ var mParticle = (function () {
       var self = this;
       // Public
       this.attemptCookieSync = function (mpid, mpidIsNotInCookies) {
-        var _a = mpInstance._Store,
-          pixelConfigurations = _a.pixelConfigurations,
-          webviewBridgeEnabled = _a.webviewBridgeEnabled;
+        var _a;
+        var _b = mpInstance._Store,
+          pixelConfigurations = _b.pixelConfigurations,
+          webviewBridgeEnabled = _b.webviewBridgeEnabled;
         if (!mpid || webviewBridgeEnabled) {
           return;
         }
+        // When noFunctional is true, persistence is not saved, so we cannot track cookie sync
+        // dates. Skip cookie sync to avoid running it on every page load.
+        if ((_a = mpInstance._CookieConsentManager) === null || _a === void 0 ? void 0 : _a.getNoFunctional()) {
+          return;
+        }
         var persistence = mpInstance._Persistence.getPersistence();
         if (isEmpty(persistence)) {
           return;
@@ -3579,172 +3815,15 @@ var mParticle = (function () {
       return new Date().getTime() > new Date(lastSyncDate).getTime() + frequencyCap * DAYS_IN_MILLISECONDS;
     };
 
-    var _a = Constants.IdentityMethods,
-      Identify$2 = _a.Identify,
-      Modify$3 = _a.Modify,
-      Login$2 = _a.Login,
-      Logout$2 = _a.Logout;
-    var CACHE_HEADER = 'x-mp-max-age';
-    var cacheOrClearIdCache = function cacheOrClearIdCache(method, knownIdentities, idCache, identityResponse, parsingCachedResponse) {
-      // when parsing a response that has already been cached, simply return instead of attempting another cache
-      if (parsingCachedResponse) {
-        return;
-      }
-      // default the expire timestamp to one day in milliseconds unless a header comes back
-      var expireTimestamp = getExpireTimestamp(identityResponse === null || identityResponse === void 0 ? void 0 : identityResponse.cacheMaxAge);
-      switch (method) {
-        case Login$2:
-        case Identify$2:
-          cacheIdentityRequest(method, knownIdentities, expireTimestamp, idCache, identityResponse);
-          break;
-        case Modify$3:
-        case Logout$2:
-          idCache.purge();
-          break;
-      }
-    };
-    var cacheIdentityRequest = function cacheIdentityRequest(method, identities, expireTimestamp, idCache, identityResponse) {
-      var responseText = identityResponse.responseText,
-        status = identityResponse.status;
-      var cache = idCache.retrieve() || {};
-      var cacheKey = concatenateIdentities(method, identities);
-      var hashedKey = generateHash(cacheKey);
-      var mpid = responseText.mpid,
-        is_logged_in = responseText.is_logged_in;
-      var cachedResponseBody = {
-        mpid: mpid,
-        is_logged_in: is_logged_in
-      };
-      cache[hashedKey] = {
-        responseText: JSON.stringify(cachedResponseBody),
-        status: status,
-        expireTimestamp: expireTimestamp
-      };
-      idCache.store(cache);
-    };
-    // We need to ensure that identities are concatenated in a deterministic way, so
-    // we sort the identities based on their enum.
-    // we create an array, set the user identity at the index of the user identity type
-    var concatenateIdentities = function concatenateIdentities(method, userIdentities) {
-      var DEVICE_APPLICATION_STAMP = 'device_application_stamp';
-      // set DAS first since it is not an official identity type
-      var cacheKey = "".concat(method, ":").concat(DEVICE_APPLICATION_STAMP, "=").concat(userIdentities.device_application_stamp, ";");
-      var idLength = Object.keys(userIdentities).length;
-      var concatenatedIdentities = '';
-      if (idLength) {
-        var userIDArray = new Array();
-        // create an array where each index is equal to the user identity type
-        for (var key in userIdentities) {
-          if (key === DEVICE_APPLICATION_STAMP) {
-            continue;
-          } else {
-            userIDArray[Types.IdentityType.getIdentityType(key)] = userIdentities[key];
-          }
-        }
-        concatenatedIdentities = userIDArray.reduce(function (prevValue, currentValue, index) {
-          var idName = Types.IdentityType.getIdentityName(index);
-          return "".concat(prevValue).concat(idName, "=").concat(currentValue, ";");
-        }, cacheKey);
-      }
-      return concatenatedIdentities;
-    };
-    var hasValidCachedIdentity = function hasValidCachedIdentity(method, proposedUserIdentities, idCache) {
-      // There is an edge case where multiple identity calls are taking place
-      // before identify fires, so there may not be a cache.  See what happens when
-      // the ? in idCache is removed to the following test
-      // "queued events contain login mpid instead of identify mpid when calling
-      // login immediately after mParticle initializes"
-      var cache = idCache === null || idCache === void 0 ? void 0 : idCache.retrieve();
-      // if there is no cache, then there is no valid cached identity
-      if (!cache) {
-        return false;
-      }
-      var cacheKey = concatenateIdentities(method, proposedUserIdentities);
-      var hashedKey = generateHash(cacheKey);
-      // if cache doesn't have the cacheKey, there is no valid cached identity
-      if (!cache.hasOwnProperty(hashedKey)) {
-        return false;
-      }
-      // If there is a valid cache key, compare the expireTimestamp to the current time.
-      // If the current time is greater than the expireTimestamp, it is not a valid
-      // cached identity.
-      var expireTimestamp = cache[hashedKey].expireTimestamp;
-      if (expireTimestamp < new Date().getTime()) {
-        return false;
-      } else {
-        return true;
-      }
-    };
-    var getCachedIdentity = function getCachedIdentity(method, proposedUserIdentities, idCache) {
-      var cacheKey = concatenateIdentities(method, proposedUserIdentities);
-      var hashedKey = generateHash(cacheKey);
-      var cache = idCache.retrieve();
-      var cachedIdentity = cache ? cache[hashedKey] : null;
-      return {
-        responseText: parseIdentityResponse(cachedIdentity.responseText),
-        expireTimestamp: cachedIdentity.expireTimestamp,
-        status: cachedIdentity.status
-      };
-    };
-    // https://go.mparticle.com/work/SQDSDKS-6079
-    var createKnownIdentities = function createKnownIdentities(identityApiData, deviceId) {
-      var identitiesResult = {};
-      if (isObject(identityApiData === null || identityApiData === void 0 ? void 0 : identityApiData.userIdentities)) {
-        for (var identity in identityApiData.userIdentities) {
-          identitiesResult[identity] = identityApiData.userIdentities[identity];
-        }
-      }
-      identitiesResult.device_application_stamp = deviceId;
-      return identitiesResult;
-    };
-    var removeExpiredIdentityCacheDates = function removeExpiredIdentityCacheDates(idCache) {
-      var cache = idCache.retrieve() || {};
-      var currentTime = new Date().getTime();
-      // Iterate over the cache and remove any key/value pairs that are expired
-      for (var key in cache) {
-        if (cache[key].expireTimestamp < currentTime) {
-          delete cache[key];
-        }
-      }
-      idCache.store(cache);
-    };
-    var tryCacheIdentity = function tryCacheIdentity(knownIdentities, idCache, parseIdentityResponse, mpid, callback, identityApiData, identityMethod) {
-      // https://go.mparticle.com/work/SQDSDKS-6095
-      var shouldReturnCachedIdentity = hasValidCachedIdentity(identityMethod, knownIdentities, idCache);
-      // If Identity is cached, then immediately parse the identity response
-      if (shouldReturnCachedIdentity) {
-        var cachedIdentity = getCachedIdentity(identityMethod, knownIdentities, idCache);
-        parseIdentityResponse(cachedIdentity, mpid, callback, identityApiData, identityMethod, knownIdentities, true);
-        return true;
-      }
-      return false;
-    };
-    var getExpireTimestamp = function getExpireTimestamp(maxAge) {
-      if (maxAge === void 0) {
-        maxAge = ONE_DAY_IN_SECONDS;
-      }
-      return new Date().getTime() + maxAge * MILLIS_IN_ONE_SEC;
-    };
-    var parseIdentityResponse = function parseIdentityResponse(responseText) {
-      return responseText ? JSON.parse(responseText) : {};
-    };
-    var hasIdentityRequestChanged = function hasIdentityRequestChanged(currentUser, newIdentityRequest) {
-      if (!currentUser || !(newIdentityRequest === null || newIdentityRequest === void 0 ? void 0 : newIdentityRequest.userIdentities)) {
-        return false;
-      }
-      var currentUserIdentities = currentUser.getUserIdentities().userIdentities;
-      var newIdentities = newIdentityRequest.userIdentities;
-      return JSON.stringify(currentUserIdentities) !== JSON.stringify(newIdentities);
-    };
-
     var Messages$6 = Constants.Messages;
     function SessionManager(mpInstance) {
       var self = this;
       this.initialize = function () {
+        var _a;
         if (mpInstance._Store.sessionId) {
-          var _a = mpInstance._Store,
-            dateLastEventSent = _a.dateLastEventSent,
-            SDKConfig = _a.SDKConfig;
+          var _b = mpInstance._Store,
+            dateLastEventSent = _b.dateLastEventSent,
+            SDKConfig = _b.SDKConfig;
           var sessionTimeout = SDKConfig.sessionTimeout;
           if (hasSessionTimedOut(dateLastEventSent === null || dateLastEventSent === void 0 ? void 0 : dateLastEventSent.getTime(), sessionTimeout)) {
             self.endSession();
@@ -3754,7 +3833,8 @@ var mParticle = (function () {
             // https://go.mparticle.com/work/SQDSDKS-6323
             var currentUser = mpInstance.Identity.getCurrentUser();
             var sdkIdentityRequest = SDKConfig.identifyRequest;
-            if (hasIdentityRequestChanged(currentUser, sdkIdentityRequest)) {
+            var shouldSuppressIdentify = ((_a = mpInstance._CookieConsentManager) === null || _a === void 0 ? void 0 : _a.getNoFunctional()) && !hasExplicitIdentifier(mpInstance._Store);
+            if (!shouldSuppressIdentify && hasIdentityRequestChanged(currentUser, sdkIdentityRequest)) {
               mpInstance.Identity.identify(sdkIdentityRequest, SDKConfig.identityCallback);
               mpInstance._Store.identifyCalled = true;
               mpInstance._Store.SDKConfig.identityCallback = null;
@@ -3772,6 +3852,7 @@ var mParticle = (function () {
         return mpInstance._Store.sessionId;
       };
       this.startNewSession = function () {
+        var _a;
         mpInstance.Logger.verbose(Messages$6.InformationMessages.StartingNewSession);
         if (mpInstance._Helpers.canLog()) {
           mpInstance._Store.sessionId = mpInstance._Helpers.generateUniqueId().toUpperCase();
@@ -3786,7 +3867,8 @@ var mParticle = (function () {
             mpInstance._Store.dateLastEventSent = date;
           }
           self.setSessionTimer();
-          if (!mpInstance._Store.identifyCalled) {
+          var shouldSuppressIdentify = ((_a = mpInstance._CookieConsentManager) === null || _a === void 0 ? void 0 : _a.getNoFunctional()) && !hasExplicitIdentifier(mpInstance._Store);
+          if (!mpInstance._Store.identifyCalled && !shouldSuppressIdentify) {
             mpInstance.Identity.identify(mpInstance._Store.SDKConfig.identifyRequest, mpInstance._Store.SDKConfig.identityCallback);
             mpInstance._Store.identifyCalled = true;
             mpInstance._Store.SDKConfig.identityCallback = null;
@@ -4312,14 +4394,20 @@ var mParticle = (function () {
     }
 
     var ForegroundTimeTracker = /** @class */function () {
-      function ForegroundTimeTracker(timerKey) {
+      function ForegroundTimeTracker(timerKey, noFunctional) {
+        if (noFunctional === void 0) {
+          noFunctional = false;
+        }
+        this.noFunctional = noFunctional;
         this.isTrackerActive = false;
         this.localStorageName = '';
         this.startTime = 0;
         this.totalTime = 0;
         this.localStorageName = "mprtcl-tos-".concat(timerKey);
         this.timerVault = new LocalStorageVault(this.localStorageName);
-        this.loadTimeFromStorage();
+        if (!this.noFunctional) {
+          this.loadTimeFromStorage();
+        }
         this.addHandlers();
         if (document.hidden === false) {
           this.startTracking();
@@ -4372,7 +4460,7 @@ var mParticle = (function () {
         }
       };
       ForegroundTimeTracker.prototype.updateTimeInPersistence = function () {
-        if (this.isTrackerActive) {
+        if (this.isTrackerActive && !this.noFunctional) {
           this.timerVault.store(Math.round(this.totalTime));
         }
       };
@@ -4432,6 +4520,8 @@ var mParticle = (function () {
       for (var prop in Constants.DefaultBaseUrls) {
         sdkConfig[prop] = Constants.DefaultBaseUrls[prop];
       }
+      // Always initialize flags to at least an empty object to prevent undefined access
+      sdkConfig.flags = sdkConfig.flags || {};
       return sdkConfig;
     }
     // TODO: Merge this with SDKStoreApi in sdkRuntimeModels
@@ -4484,6 +4574,8 @@ var mParticle = (function () {
           version: null,
           isInfoSet: false
         },
+        roktAccountId: null,
+        integrationName: null,
         // Placeholder for in-memory persistence model
         persistenceData: {
           gs: {}
@@ -4500,10 +4592,6 @@ var mParticle = (function () {
         if (!config.hasOwnProperty('flags')) {
           this.SDKConfig.flags = {};
         }
-        // We process the initial config that is passed via the SDK init
-        // and then we will reprocess the config within the processConfig
-        // function when the config is updated from the server
-        // https://go.mparticle.com/work/SQDSDKS-6317
         this.SDKConfig.flags = processFlags(config);
         if (config.deviceId) {
           this.deviceId = config.deviceId;
@@ -4517,9 +4605,6 @@ var mParticle = (function () {
         for (var baseUrlKeys in baseUrls) {
           this.SDKConfig[baseUrlKeys] = baseUrls[baseUrlKeys];
         }
-        if (config.hasOwnProperty('logLevel')) {
-          this.SDKConfig.logLevel = config.logLevel;
-        }
         this.SDKConfig.useNativeSdk = !!config.useNativeSdk;
         this.SDKConfig.kits = config.kits || {};
         this.SDKConfig.sideloadedKits = config.sideloadedKits || [];
@@ -4742,6 +4827,18 @@ var mParticle = (function () {
       this.setUserIdentities = function (mpid, userIdentities) {
         _this._setPersistence(mpid, 'ui', userIdentities);
       };
+      this.getRoktAccountId = function () {
+        return _this.roktAccountId;
+      };
+      this.setRoktAccountId = function (accountId) {
+        _this.roktAccountId = accountId;
+      };
+      this.getIntegrationName = function () {
+        return _this.integrationName;
+      };
+      this.setIntegrationName = function (integrationName) {
+        _this.integrationName = integrationName;
+      };
       this.addMpidToSessionHistory = function (mpid, previousMPID) {
         var indexOfMPID = _this.currentSessionMPIDs.indexOf(mpid);
         if (mpid && previousMPID !== mpid && indexOfMPID < 0) {
@@ -4761,19 +4858,24 @@ var mParticle = (function () {
         mpInstance._Persistence.update();
       };
       this.processConfig = function (config) {
+        var _a;
         var workspaceToken = config.workspaceToken,
           requiredWebviewBridgeName = config.requiredWebviewBridgeName;
         // We should reprocess the flags and baseUrls in case they have changed when we request an updated config
         // such as if the SDK is being self-hosted and the flags are different on the server config
         // https://go.mparticle.com/work/SQDSDKS-6317
-        _this.SDKConfig.flags = processFlags(config);
+        // Only update flags if the config actually has flags (don't overwrite with empty object)
+        if (config.flags) {
+          _this.SDKConfig.flags = processFlags(config);
+        }
         var baseUrls = processBaseUrls(config, _this.SDKConfig.flags, apiKey);
         for (var baseUrlKeys in baseUrls) {
           _this.SDKConfig[baseUrlKeys] = baseUrls[baseUrlKeys];
         }
         if (workspaceToken) {
           _this.SDKConfig.workspaceToken = workspaceToken;
-          mpInstance._timeOnSiteTimer = new ForegroundTimeTracker(workspaceToken);
+          var noFunctional = ((_a = config === null || config === void 0 ? void 0 : config.launcherOptions) === null || _a === void 0 ? void 0 : _a.noFunctional) === true;
+          mpInstance._timeOnSiteTimer = new ForegroundTimeTracker(workspaceToken, noFunctional);
         } else {
           mpInstance.Logger.warning('You should have a workspaceToken on your config object for security purposes.');
         }
@@ -4866,7 +4968,7 @@ var mParticle = (function () {
       for (var baseUrlKey in defaultBaseUrls) {
         // Any custom endpoints passed to mpConfig will take priority over direct
         // mapping to the silo.  The most common use case is a customer provided CNAME.
-        if (baseUrlKey === 'configUrl') {
+        if (baseUrlKey === 'configUrl' || baseUrlKey === 'loggingUrl' || baseUrlKey === 'errorUrl') {
           directBaseUrls[baseUrlKey] = config[baseUrlKey] || defaultBaseUrls[baseUrlKey];
           continue;
         }
@@ -4881,10 +4983,11 @@ var mParticle = (function () {
     }
 
     var Logger = /** @class */function () {
-      function Logger(config) {
+      function Logger(config, reportingLogger) {
         var _a, _b;
         this.logLevel = (_a = config.logLevel) !== null && _a !== void 0 ? _a : LogLevelType.Warning;
         this.logger = (_b = config.logger) !== null && _b !== void 0 ? _b : new ConsoleLogger();
+        this.reportingLogger = reportingLogger;
       }
       Logger.prototype.verbose = function (msg) {
         if (this.logLevel === LogLevelType.None) return;
@@ -4898,10 +5001,14 @@ var mParticle = (function () {
           this.logger.warning(msg);
         }
       };
-      Logger.prototype.error = function (msg) {
+      Logger.prototype.error = function (msg, codeForReporting) {
+        var _a;
         if (this.logLevel === LogLevelType.None) return;
         if (this.logger.error) {
           this.logger.error(msg);
+          if (codeForReporting) {
+            (_a = this.reportingLogger) === null || _a === void 0 ? void 0 : _a.error(msg, codeForReporting);
+          }
         }
       };
       Logger.prototype.setLogLevel = function (newLogLevel) {
@@ -5102,9 +5209,15 @@ var mParticle = (function () {
 
       // https://go.mparticle.com/work/SQDSDKS-6021
       this.setLocalStorage = function () {
+        var _mpInstance$_CookieCo;
         if (!mpInstance._Store.isLocalStorageAvailable) {
           return;
         }
+
+        // Block mprtcl-v4 localStorage when noFunctional is true
+        if ((_mpInstance$_CookieCo = mpInstance._CookieConsentManager) !== null && _mpInstance$_CookieCo !== void 0 && _mpInstance$_CookieCo.getNoFunctional()) {
+          return;
+        }
         var key = mpInstance._Store.storageName,
           localStorageData = self.getLocalStorage() || {},
           currentUser = mpInstance.Identity.getCurrentUser(),
@@ -5230,6 +5343,11 @@ var mParticle = (function () {
       // https://go.mparticle.com/work/SQDSDKS-5022
       // https://go.mparticle.com/work/SQDSDKS-6021
       this.setCookie = function () {
+        var _mpInstance$_CookieCo2;
+        // Block mprtcl-v4 cookies when noFunctional is true
+        if ((_mpInstance$_CookieCo2 = mpInstance._CookieConsentManager) !== null && _mpInstance$_CookieCo2 !== void 0 && _mpInstance$_CookieCo2.getNoFunctional()) {
+          return;
+        }
         var mpid,
           currentUser = mpInstance.Identity.getCurrentUser();
         if (currentUser) {
@@ -5505,6 +5623,11 @@ var mParticle = (function () {
 
       // https://go.mparticle.com/work/SQDSDKS-6021
       this.savePersistence = function (persistence) {
+        var _mpInstance$_CookieCo3;
+        // Block mprtcl-v4 persistence when noFunctional is true
+        if ((_mpInstance$_CookieCo3 = mpInstance._CookieConsentManager) !== null && _mpInstance$_CookieCo3 !== void 0 && _mpInstance$_CookieCo3.getNoFunctional()) {
+          return;
+        }
         var encodedPersistence = self.encodePersistence(JSON.stringify(persistence)),
           date = new Date(),
           key = mpInstance._Store.storageName,
@@ -9161,6 +9284,17 @@ var mParticle = (function () {
       };
     }
 
+    var ErrorCodes = {
+      UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+      UNHANDLED_EXCEPTION: 'UNHANDLED_EXCEPTION',
+      IDENTITY_REQUEST: 'IDENTITY_REQUEST'
+    };
+    var WSDKErrorSeverity = {
+      ERROR: 'ERROR',
+      INFO: 'INFO',
+      WARNING: 'WARNING'
+    };
+
     var HTTPCodes$1 = Constants.HTTPCodes,
       Messages$1 = Constants.Messages,
       IdentityMethods = Constants.IdentityMethods;
@@ -9373,7 +9507,7 @@ var mParticle = (function () {
                   mpInstance.captureTiming("".concat(requestCount, "-identityRequestEnd"));
                 }
                 errorMessage = err_1.message || err_1.toString();
-                Logger.error('Error sending identity request to servers - ' + errorMessage);
+                Logger.error('Error sending identity request to servers' + ' - ' + errorMessage, ErrorCodes.IDENTITY_REQUEST);
                 (_d = mpInstance.processQueueOnIdentityFailure) === null || _d === void 0 ? void 0 : _d.call(mpInstance);
                 invokeCallback(callback, HTTPCodes$1.noHttpCoverage, errorMessage);
                 return [3 /*break*/, 10];
@@ -9793,13 +9927,19 @@ var mParticle = (function () {
         configurable: true
       });
       RoktManager.prototype.attachKit = function (kit) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         this.kit = kit;
+        if ((_a = kit.settings) === null || _a === void 0 ? void 0 : _a.accountId) {
+          this.store.setRoktAccountId(kit.settings.accountId);
+        }
+        if (kit.integrationName) {
+          (_b = this.store) === null || _b === void 0 ? void 0 : _b.setIntegrationName(kit.integrationName);
+        }
         this.processMessageQueue();
         try {
-          (_a = this.onReadyCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+          (_c = this.onReadyCallback) === null || _c === void 0 ? void 0 : _c.call(this);
         } catch (e) {
-          (_b = this.logger) === null || _b === void 0 ? void 0 : _b.error('RoktManager: Error in onReadyCallback: ' + e);
+          (_d = this.logger) === null || _d === void 0 ? void 0 : _d.error('RoktManager: Error in onReadyCallback: ' + e);
         }
       };
       /**
@@ -10239,6 +10379,138 @@ var mParticle = (function () {
       return CookieConsentManager;
     }();
 
+    // Header key constants
+    var HEADER_ACCEPT = 'Accept';
+    var HEADER_CONTENT_TYPE = 'Content-Type';
+    var HEADER_ROKT_LAUNCHER_VERSION = 'rokt-launcher-version';
+    var HEADER_ROKT_LAUNCHER_INSTANCE_GUID = 'rokt-launcher-instance-guid';
+    var HEADER_ROKT_WSDK_VERSION = 'rokt-wsdk-version';
+    var ReportingLogger = /** @class */function () {
+      function ReportingLogger(config, sdkVersion, store, launcherInstanceGuid, rateLimiter) {
+        var _this = this;
+        this.sdkVersion = sdkVersion;
+        this.launcherInstanceGuid = launcherInstanceGuid;
+        this.reporter = 'mp-wsdk';
+        this.isFeatureFlagEnabled = function () {
+          return _this.isLoggingEnabled;
+        };
+        this.loggingUrl = "https://".concat(config.loggingUrl || Constants.DefaultBaseUrls.loggingUrl);
+        this.errorUrl = "https://".concat(config.errorUrl || Constants.DefaultBaseUrls.errorUrl);
+        this.isLoggingEnabled = config.isLoggingEnabled || false;
+        this.store = store !== null && store !== void 0 ? store : null;
+        this.isEnabled = this.isReportingEnabled();
+        this.rateLimiter = rateLimiter !== null && rateLimiter !== void 0 ? rateLimiter : new RateLimiter();
+      }
+      ReportingLogger.prototype.setStore = function (store) {
+        this.store = store;
+      };
+      ReportingLogger.prototype.info = function (msg, code) {
+        this.sendLog(WSDKErrorSeverity.INFO, msg, code);
+      };
+      ReportingLogger.prototype.error = function (msg, code, stackTrace) {
+        this.sendError(WSDKErrorSeverity.ERROR, msg, code, stackTrace);
+      };
+      ReportingLogger.prototype.warning = function (msg, code) {
+        this.sendError(WSDKErrorSeverity.WARNING, msg, code);
+      };
+      ReportingLogger.prototype.sendToServer = function (url, severity, msg, code, stackTrace) {
+        if (!this.canSendLog(severity)) return;
+        try {
+          var logRequest = this.buildLogRequest(severity, msg, code, stackTrace);
+          var uploader = new FetchUploader(url);
+          var payload = {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(logRequest)
+          };
+          uploader.upload(payload)["catch"](function (error) {
+            console.error('ReportingLogger: Failed to send log', error);
+          });
+        } catch (error) {
+          console.error('ReportingLogger: Failed to send log', error);
+        }
+      };
+      ReportingLogger.prototype.sendLog = function (severity, msg, code, stackTrace) {
+        this.sendToServer(this.loggingUrl, severity, msg, code, stackTrace);
+      };
+      ReportingLogger.prototype.sendError = function (severity, msg, code, stackTrace) {
+        this.sendToServer(this.errorUrl, severity, msg, code, stackTrace);
+      };
+      ReportingLogger.prototype.buildLogRequest = function (severity, msg, code, stackTrace) {
+        var _a, _b;
+        return {
+          additionalInformation: {
+            message: msg,
+            version: this.getVersion()
+          },
+          severity: severity,
+          code: code !== null && code !== void 0 ? code : ErrorCodes.UNKNOWN_ERROR,
+          url: this.getUrl(),
+          deviceInfo: this.getUserAgent(),
+          stackTrace: stackTrace,
+          reporter: this.reporter,
+          // Integration will be set to integrationName once the kit connects via RoktManager.attachKit()
+          integration: (_b = (_a = this.store) === null || _a === void 0 ? void 0 : _a.getIntegrationName()) !== null && _b !== void 0 ? _b : 'mp-wsdk'
+        };
+      };
+      ReportingLogger.prototype.getVersion = function () {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.store) === null || _a === void 0 ? void 0 : _a.getIntegrationName) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : "mParticle_wsdkv_".concat(this.sdkVersion);
+      };
+      ReportingLogger.prototype.isReportingEnabled = function () {
+        return this.isDebugModeEnabled() || this.isRoktDomainPresent() && this.isFeatureFlagEnabled();
+      };
+      ReportingLogger.prototype.isRoktDomainPresent = function () {
+        return typeof window !== 'undefined' && Boolean(window['ROKT_DOMAIN']);
+      };
+      ReportingLogger.prototype.isDebugModeEnabled = function () {
+        var _a, _b, _c, _d;
+        return typeof window !== 'undefined' && ((_d = (_c = (_b = (_a = window.location) === null || _a === void 0 ? void 0 : _a.search) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === null || _c === void 0 ? void 0 : _c.includes('mp_enable_logging=true')) !== null && _d !== void 0 ? _d : false);
+      };
+      ReportingLogger.prototype.canSendLog = function (severity) {
+        return this.isEnabled && !this.isRateLimited(severity);
+      };
+      ReportingLogger.prototype.isRateLimited = function (severity) {
+        return this.rateLimiter.incrementAndCheck(severity);
+      };
+      ReportingLogger.prototype.getUrl = function () {
+        var _a;
+        return typeof window !== 'undefined' ? (_a = window.location) === null || _a === void 0 ? void 0 : _a.href : undefined;
+      };
+      ReportingLogger.prototype.getUserAgent = function () {
+        var _a;
+        return typeof window !== 'undefined' ? (_a = window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent : undefined;
+      };
+      ReportingLogger.prototype.getHeaders = function () {
+        var _a;
+        var _b, _c;
+        var headers = (_a = {}, _a[HEADER_ACCEPT] = 'text/plain;charset=UTF-8', _a[HEADER_CONTENT_TYPE] = 'application/json', _a[HEADER_ROKT_LAUNCHER_VERSION] = this.getVersion(), _a[HEADER_ROKT_WSDK_VERSION] = 'joint', _a);
+        if (this.launcherInstanceGuid) {
+          headers[HEADER_ROKT_LAUNCHER_INSTANCE_GUID] = this.launcherInstanceGuid;
+        }
+        var accountId = (_c = (_b = this.store) === null || _b === void 0 ? void 0 : _b.getRoktAccountId) === null || _c === void 0 ? void 0 : _c.call(_b);
+        if (accountId) {
+          headers['rokt-account-id'] = accountId;
+        }
+        return headers;
+      };
+      return ReportingLogger;
+    }();
+    var RateLimiter = /** @class */function () {
+      function RateLimiter() {
+        this.rateLimits = new Map([[WSDKErrorSeverity.ERROR, 10], [WSDKErrorSeverity.WARNING, 10], [WSDKErrorSeverity.INFO, 10]]);
+        this.logCount = new Map();
+      }
+      RateLimiter.prototype.incrementAndCheck = function (severity) {
+        var count = this.logCount.get(severity) || 0;
+        var limit = this.rateLimits.get(severity) || 10;
+        var newCount = count + 1;
+        this.logCount.set(severity, newCount);
+        return newCount > limit;
+      };
+      return RateLimiter;
+    }();
+
     var Messages = Constants.Messages,
       HTTPCodes = Constants.HTTPCodes,
       FeatureFlags = Constants.FeatureFlags,
@@ -10296,6 +10568,19 @@ var mParticle = (function () {
           self._preInit.readyQueue = processReadyQueue(self._preInit.readyQueue);
         }
       };
+      /**
+       * Drains the ready queue for noFunctional sessions with no explicit identity.
+       */
+      this.processQueueOnNoFunctional = function () {
+        var _a, _b;
+        if ((_a = self._Store) === null || _a === void 0 ? void 0 : _a.isInitialized) {
+          return;
+        }
+        var noFunctionalWithoutId = ((_b = self._CookieConsentManager) === null || _b === void 0 ? void 0 : _b.getNoFunctional()) && !hasExplicitIdentifier(self._Store);
+        if (noFunctionalWithoutId) {
+          self._preInit.readyQueue = processReadyQueue(self._preInit.readyQueue);
+        }
+      };
       // required for forwarders once they reference the mparticle instance
       this.IdentityType = IdentityType;
       this.EventType = EventType;
@@ -10363,12 +10648,14 @@ var mParticle = (function () {
           console.error('Cannot reset mParticle', error);
         }
       };
-      this._resetForTests = function (config, keepPersistence, instance) {
+      this._resetForTests = function (config, keepPersistence, instance, reportingLogger) {
         if (instance._Store) {
           delete instance._Store;
         }
-        instance.Logger = new Logger(config);
+        instance.Logger = new Logger(config, reportingLogger);
         instance._Store = new Store(config, instance);
+        // Update ReportingLogger with the new Store reference to avoid stale data
+        reportingLogger === null || reportingLogger === void 0 ? void 0 : reportingLogger.setStore(instance._Store);
         instance._Store.isLocalStorageAvailable = instance._Persistence.determineLocalStorageAvailability(window.localStorage);
         instance._Events.stopTracking();
         if (!keepPersistence) {
@@ -10391,8 +10678,9 @@ var mParticle = (function () {
        * @param {Function} f Callback to execute
        */
       this.ready = function (f) {
-        var _a, _b;
-        var shouldExecute = isFunction(f) && (((_a = self._Store) === null || _a === void 0 ? void 0 : _a.isInitialized) || ((_b = self._Store) === null || _b === void 0 ? void 0 : _b.identityCallFailed) && self._RoktManager.isReady());
+        var _a, _b, _c;
+        var noFunctionalWithoutId = ((_a = self._CookieConsentManager) === null || _a === void 0 ? void 0 : _a.getNoFunctional()) && !hasExplicitIdentifier(self._Store);
+        var shouldExecute = isFunction(f) && (((_b = self._Store) === null || _b === void 0 ? void 0 : _b.isInitialized) || ((_c = self._Store) === null || _c === void 0 ? void 0 : _c.identityCallFailed) && self._RoktManager.isReady() || noFunctionalWithoutId);
         if (shouldExecute) {
           f();
         } else {
@@ -10996,10 +11284,14 @@ var mParticle = (function () {
        * @param {String or Number} value value for session attribute
        */
       this.setSessionAttribute = function (key, value) {
-        var queued = queueIfNotInitialized(function () {
-          self.setSessionAttribute(key, value);
-        }, self);
-        if (queued) return;
+        var _a;
+        var skipQueue = ((_a = self._CookieConsentManager) === null || _a === void 0 ? void 0 : _a.getNoFunctional()) && !hasExplicitIdentifier(self._Store);
+        if (!skipQueue) {
+          var queued = queueIfNotInitialized(function () {
+            self.setSessionAttribute(key, value);
+          }, self);
+          if (queued) return;
+        }
         // Logs to cookie
         // And logs to in-memory object
         // Example: mParticle.setSessionAttribute('location', '33431');
@@ -11185,6 +11477,9 @@ var mParticle = (function () {
           window[launcherInstanceGuidKey] = self._Helpers.generateUniqueId();
         }
       };
+      this.getLauncherInstanceGuid = function () {
+        return window[launcherInstanceGuidKey];
+      };
       this.captureTiming = function (metricsName) {
         var _a;
         if (typeof window !== 'undefined' && ((_a = window.performance) === null || _a === void 0 ? void 0 : _a.mark)) {
@@ -11194,6 +11489,7 @@ var mParticle = (function () {
     }
     // Some (server) config settings need to be returned before they are set on SDKConfig in a self hosted environment
     function completeSDKInitialization(apiKey, config, mpInstance) {
+      var _a, _b;
       var kitBlocker = createKitBlocker(config, mpInstance);
       var getFeatureFlag = mpInstance._Helpers.getFeatureFlag;
       mpInstance._APIClient = new APIClient(mpInstance, kitBlocker);
@@ -11239,6 +11535,8 @@ var mParticle = (function () {
         // Configure Rokt Manager with user and filtered user
         var roktConfig = parseConfig(config, 'Rokt', 181);
         if (roktConfig) {
+          var accountId = (_a = roktConfig.settings) === null || _a === void 0 ? void 0 : _a.accountId;
+          mpInstance._Store.setRoktAccountId(accountId);
           var userAttributeFilters = roktConfig.userAttributeFilters;
           var roktFilteredUser = filteredMparticleUser(currentUserMPID, {
             userAttributeFilters: userAttributeFilters
@@ -11265,6 +11563,9 @@ var mParticle = (function () {
         mpInstance._Store.isInitialized = true;
         mpInstance._preInit.readyQueue = processReadyQueue(mpInstance._preInit.readyQueue);
       }
+      // For noFunctional sessions with no identity, drain any pre-init ready callbacks
+      // that were queued before _CookieConsentManager was available to evaluate the condition.
+      (_b = mpInstance.processQueueOnNoFunctional) === null || _b === void 0 ? void 0 : _b.call(mpInstance);
       // https://go.mparticle.com/work/SQDSDKS-6040
       if (mpInstance._Store.isFirstRun) {
         mpInstance._Store.isFirstRun = false;
@@ -11330,15 +11631,25 @@ var mParticle = (function () {
       return kitBlocker;
     }
     function createIdentityCache(mpInstance) {
+      var _a;
+      // Identity expects mpInstance._Identity.idCache to always exist. DisabledVault
+      // ensures no identity response data is written to localStorage when noFunctional is true
+      if ((_a = mpInstance._CookieConsentManager) === null || _a === void 0 ? void 0 : _a.getNoFunctional()) {
+        return new DisabledVault("".concat(mpInstance._Store.storageName, "-id-cache"), {
+          logger: mpInstance.Logger
+        });
+      }
       return new LocalStorageVault("".concat(mpInstance._Store.storageName, "-id-cache"), {
         logger: mpInstance.Logger
       });
     }
     function runPreConfigFetchInitialization(mpInstance, apiKey, config) {
       var _a;
-      mpInstance.Logger = new Logger(config);
+      mpInstance._ReportingLogger = new ReportingLogger(config, Constants.sdkVersion, undefined, mpInstance.getLauncherInstanceGuid());
+      mpInstance.Logger = new Logger(config, mpInstance._ReportingLogger);
       mpInstance._Store = new Store(config, mpInstance, apiKey);
       window.mParticle.Store = mpInstance._Store;
+      mpInstance._ReportingLogger.setStore(mpInstance._Store);
       mpInstance.Logger.verbose(StartingInitialization);
       // Initialize CookieConsentManager with privacy flags from launcherOptions
       var _b = (_a = config === null || config === void 0 ? void 0 : config.launcherOptions) !== null && _a !== void 0 ? _a : {},
@@ -11390,18 +11701,21 @@ var mParticle = (function () {
       }
     }
     function queueIfNotInitialized(func, self) {
-      var _a;
-      // Core SDK methods must wait for Store initialization
-      if (!((_a = self._Store) === null || _a === void 0 ? void 0 : _a.isInitialized)) {
-        self._preInit.readyQueue.push(function () {
-          var _a;
-          if ((_a = self._Store) === null || _a === void 0 ? void 0 : _a.isInitialized) {
-            func();
-          }
-        });
-        return true;
+      var _a, _b;
+      // When noFunctional is true with no explicit identifier, the SDK will never
+      // receive an MPID. Let these calls through so events can still reach forwarders immediately.
+      // sendEventToServer handles queuing for the MP server upload path separately.
+      var noFunctionalWithoutId = ((_a = self._CookieConsentManager) === null || _a === void 0 ? void 0 : _a.getNoFunctional()) && !hasExplicitIdentifier(self._Store);
+      if (((_b = self._Store) === null || _b === void 0 ? void 0 : _b.isInitialized) || noFunctionalWithoutId) {
+        return false;
       }
-      return false;
+      self._preInit.readyQueue.push(function () {
+        var _a;
+        if ((_a = self._Store) === null || _a === void 0 ? void 0 : _a.isInitialized) {
+          func();
+        }
+      });
+      return true;
     }
 
     // This file is used ONLY for the mParticle ESLint plugin. It should NOT be used otherwise!