@azure/msal-browser 4.24.0 → 5.0.0-alpha.0

package/dist/cache/BrowserCacheManager.mjs

@@ -1,6 +1,6 @@
-/*! @azure/msal-browser v4.24.0 2025-09-24 */
+/*! @azure/msal-browser v5.0.0-alpha.0 2025-10-02 */
 'use strict';
-import { CacheManager, CacheHelpers, TimeUtils, DEFAULT_TOKEN_RENEWAL_OFFSET_SEC, createCacheError, CacheErrorCodes, invokeAsync, PerformanceEvents, AccountEntity, Constants, PersistentCacheKeys, StringUtils, AuthenticationScheme, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION, CredentialType } from '@azure/msal-common/browser';
+import { CacheManager, CacheHelpers, TimeUtils, Constants, createCacheError, CacheErrorCodes, invokeAsync, PerformanceEvents, AccountEntityUtils, StringUtils, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION } from '@azure/msal-common/browser';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { BrowserCacheLocation, InMemoryCacheKeys, TemporaryCacheKeys, INTERACTION_TYPE } from '../utils/BrowserConstants.mjs';
 import { ACCOUNT_SCHEMA_VERSION, CREDENTIAL_SCHEMA_VERSION, getAccountKeysCacheKey, PREFIX, CACHE_KEY_SEPARATOR, VERSION_CACHE_KEY, getTokenKeysCacheKey } from './CacheKeys.mjs';
@@ -24,8 +24,6 @@ import { noTokenRequestCacheError, unableToParseTokenRequestCacheError, interact
  */
 /**
  * This class implements the cache storage interface for MSAL through browser local or session storage.
- * Cookies are only used if storeAuthStateInCookie is true, and are only used for
- * parameters such as state and nonce, generally.
  */
 class BrowserCacheManager extends CacheManager {
     constructor(clientId, cacheConfig, cryptoImpl, logger, performanceClient, eventHandler, staticAuthorityOptions) {
@@ -34,7 +32,7 @@ class BrowserCacheManager extends CacheManager {
         this.logger = logger;
         this.internalStorage = new MemoryStorage();
         this.browserStorage = getStorageImplementation(clientId, cacheConfig.cacheLocation, logger, performanceClient);
-        this.temporaryCacheStorage = getStorageImplementation(clientId, cacheConfig.temporaryCacheLocation, logger, performanceClient);
+        this.temporaryCacheStorage = getStorageImplementation(clientId, BrowserCacheLocation.SessionStorage, logger, performanceClient);
         this.cookieStorage = new CookieStorage();
         this.eventHandler = eventHandler;
     }
@@ -117,7 +115,7 @@ class BrowserCacheManager extends CacheManager {
             if (!decryptedData ||
                 TimeUtils.isCacheExpired(parsedV0Value.lastUpdatedAt, this.cacheConfig.cacheRetentionDays) ||
                 (expirationTime &&
-                    TimeUtils.isTokenExpired(expirationTime, DEFAULT_TOKEN_RENEWAL_OFFSET_SEC))) {
+                    TimeUtils.isTokenExpired(expirationTime, Constants.DEFAULT_TOKEN_RENEWAL_OFFSET_SEC))) {
                 this.browserStorage.removeItem(v0Key);
                 removeElementFromArray(v0Keys, v0Key);
                 this.performanceClient.incrementFields({ expiredCacheRemovedCount: 1 }, correlationId);
@@ -160,7 +158,7 @@ class BrowserCacheManager extends CacheManager {
     trackVersionChanges(correlationId) {
         const previousVersion = this.browserStorage.getItem(VERSION_CACHE_KEY);
         if (previousVersion) {
-            this.logger.info(`MSAL.js was last initialized by version: ${previousVersion}`);
+            this.logger.info(`MSAL.js was last initialized by version: '${previousVersion}'`, correlationId);
             this.performanceClient.addFields({ previousLibraryVersion: previousVersion }, correlationId);
         }
         if (previousVersion !== version) {
@@ -260,7 +258,7 @@ class BrowserCacheManager extends CacheManager {
         const maxRetries = 20;
         for (let i = 0; i <= maxRetries; i++) {
             try {
-                await invokeAsync(this.browserStorage.setUserData.bind(this.browserStorage), PerformanceEvents.SetUserData, this.logger, this.performanceClient)(key, value, correlationId, timestamp);
+                await invokeAsync(this.browserStorage.setUserData.bind(this.browserStorage), PerformanceEvents.SetUserData, this.logger, this.performanceClient, correlationId)(key, value, correlationId, timestamp);
                 if (i > 0) {
                     // Finally update the token keys array with the tokens removed
                     if (i <= tokenKeysV0Count) {
@@ -306,37 +304,30 @@ class BrowserCacheManager extends CacheManager {
      * @returns
      */
     getAccount(accountKey, correlationId) {
-        this.logger.trace("BrowserCacheManager.getAccount called");
+        this.logger.trace("BrowserCacheManager.getAccount called", correlationId);
         const serializedAccount = this.browserStorage.getUserData(accountKey);
         if (!serializedAccount) {
             this.removeAccountKeyFromMap(accountKey, correlationId);
             return null;
         }
         const parsedAccount = this.validateAndParseJson(serializedAccount);
-        if (!parsedAccount || !AccountEntity.isAccountEntity(parsedAccount)) {
+        if (!parsedAccount ||
+            !AccountEntityUtils.isAccountEntity(parsedAccount)) {
             return null;
         }
-        return CacheManager.toObject(new AccountEntity(), parsedAccount);
+        return CacheManager.toObject({}, parsedAccount);
     }
     /**
      * set account entity in the platform cache
      * @param account
      */
     async setAccount(account, correlationId) {
-        this.logger.trace("BrowserCacheManager.setAccount called");
-        const key = this.generateAccountKey(account.getAccountInfo());
+        this.logger.trace("BrowserCacheManager.setAccount called", correlationId);
+        const key = this.generateAccountKey(AccountEntityUtils.getAccountInfo(account));
         const timestamp = Date.now().toString();
         account.lastUpdatedAt = timestamp;
         await this.setUserData(key, JSON.stringify(account), correlationId, timestamp);
-        const wasAdded = this.addAccountKeyToMap(key, correlationId);
-        /**
-         * @deprecated - Remove this in next major version in favor of more consistent LOGIN event
-         */
-        if (this.cacheConfig.cacheLocation ===
-            BrowserCacheLocation.LocalStorage &&
-            wasAdded) {
-            this.eventHandler.emitEvent(EventType.ACCOUNT_ADDED, undefined, account.getAccountInfo());
-        }
+        this.addAccountKeyToMap(key, correlationId);
     }
     /**
      * Returns the array of account keys currently cached
@@ -350,18 +341,18 @@ class BrowserCacheManager extends CacheManager {
      * @param key
      */
     addAccountKeyToMap(key, correlationId) {
-        this.logger.trace("BrowserCacheManager.addAccountKeyToMap called");
-        this.logger.tracePii(`BrowserCacheManager.addAccountKeyToMap called with key: ${key}`);
+        this.logger.trace("BrowserCacheManager.addAccountKeyToMap called", correlationId);
+        this.logger.tracePii(`BrowserCacheManager.addAccountKeyToMap called with key: '${key}'`, correlationId);
         const accountKeys = this.getAccountKeys();
         if (accountKeys.indexOf(key) === -1) {
             // Only add key if it does not already exist in the map
             accountKeys.push(key);
             this.setItem(getAccountKeysCacheKey(), JSON.stringify(accountKeys), correlationId);
-            this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key added");
+            this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key added", correlationId);
             return true;
         }
         else {
-            this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key already exists in map");
+            this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key already exists in map", correlationId);
             return false;
         }
     }
@@ -370,8 +361,8 @@ class BrowserCacheManager extends CacheManager {
      * @param key
      */
     removeAccountKeyFromMap(key, correlationId) {
-        this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap called");
-        this.logger.tracePii(`BrowserCacheManager.removeAccountKeyFromMap called with key: ${key}`);
+        this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap called", correlationId);
+        this.logger.tracePii(`BrowserCacheManager.removeAccountKeyFromMap called with key: '${key}'`, correlationId);
         const accountKeys = this.getAccountKeys();
         const removalIndex = accountKeys.indexOf(key);
         if (removalIndex > -1) {
@@ -384,10 +375,10 @@ class BrowserCacheManager extends CacheManager {
             else {
                 this.setItem(getAccountKeysCacheKey(), JSON.stringify(accountKeys), correlationId);
             }
-            this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap account key removed");
+            this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap account key removed", correlationId);
         }
         else {
-            this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap key not found in existing map");
+            this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap key not found in existing map", correlationId);
         }
     }
     /**
@@ -409,12 +400,6 @@ class BrowserCacheManager extends CacheManager {
                 this.browserStorage.removeItem(key);
             }
         });
-        /**
-         * @deprecated - Remove this in next major version in favor of more consistent LOGOUT event
-         */
-        if (this.cacheConfig.cacheLocation === BrowserCacheLocation.LocalStorage) {
-            this.eventHandler.emitEvent(EventType.ACCOUNT_REMOVED, undefined, account);
-        }
     }
     /**
      * Removes given idToken from the cache and from the key map
@@ -425,7 +410,7 @@ class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         const idRemoval = tokenKeys.idToken.indexOf(key);
         if (idRemoval > -1) {
-            this.logger.info("idToken removed from tokenKeys map");
+            this.logger.info("idToken removed from tokenKeys map", correlationId);
             tokenKeys.idToken.splice(idRemoval, 1);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -445,7 +430,7 @@ class BrowserCacheManager extends CacheManager {
      * @param tokenKeys
      */
     removeAccessTokenKeys(keys, correlationId, schemaVersion = CREDENTIAL_SCHEMA_VERSION) {
-        this.logger.trace("removeAccessTokenKey called");
+        this.logger.trace("removeAccessTokenKey called", correlationId);
         const tokenKeys = this.getTokenKeys(schemaVersion);
         let keysRemoved = 0;
         keys.forEach((key) => {
@@ -456,7 +441,7 @@ class BrowserCacheManager extends CacheManager {
             }
         });
         if (keysRemoved > 0) {
-            this.logger.info(`removed ${keysRemoved} accessToken keys from tokenKeys map`);
+            this.logger.info(`removed '${keysRemoved}' accessToken keys from tokenKeys map`, correlationId);
             this.setTokenKeys(tokenKeys, correlationId, schemaVersion);
             return;
         }
@@ -470,7 +455,7 @@ class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         const refreshRemoval = tokenKeys.refreshToken.indexOf(key);
         if (refreshRemoval > -1) {
-            this.logger.info("refreshToken removed from tokenKeys map");
+            this.logger.info("refreshToken removed from tokenKeys map", correlationId);
             tokenKeys.refreshToken.splice(refreshRemoval, 1);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -483,7 +468,7 @@ class BrowserCacheManager extends CacheManager {
         return getTokenKeys(this.clientId, this.browserStorage, schemaVersion);
     }
     /**
-     * Stores the token keys in the cache
+     * Sets the token keys in the cache
      * @param tokenKeys
      * @param correlationId
      * @returns
@@ -507,16 +492,16 @@ class BrowserCacheManager extends CacheManager {
     getIdTokenCredential(idTokenKey, correlationId) {
         const value = this.browserStorage.getUserData(idTokenKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit", correlationId);
             this.removeIdToken(idTokenKey, correlationId);
             return null;
         }
         const parsedIdToken = this.validateAndParseJson(value);
         if (!parsedIdToken || !CacheHelpers.isIdTokenEntity(parsedIdToken)) {
-            this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getIdTokenCredential: cache hit");
+        this.logger.trace("BrowserCacheManager.getIdTokenCredential: cache hit", correlationId);
         return parsedIdToken;
     }
     /**
@@ -524,14 +509,14 @@ class BrowserCacheManager extends CacheManager {
      * @param idToken
      */
     async setIdTokenCredential(idToken, correlationId) {
-        this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
+        this.logger.trace("BrowserCacheManager.setIdTokenCredential called", correlationId);
         const idTokenKey = this.generateCredentialKey(idToken);
         const timestamp = Date.now().toString();
         idToken.lastUpdatedAt = timestamp;
         await this.setUserData(idTokenKey, JSON.stringify(idToken), correlationId, timestamp);
         const tokenKeys = this.getTokenKeys();
         if (tokenKeys.idToken.indexOf(idTokenKey) === -1) {
-            this.logger.info("BrowserCacheManager: addTokenKey - idToken added to map");
+            this.logger.info("BrowserCacheManager: addTokenKey - idToken added to map", correlationId);
             tokenKeys.idToken.push(idTokenKey);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -543,17 +528,17 @@ class BrowserCacheManager extends CacheManager {
     getAccessTokenCredential(accessTokenKey, correlationId) {
         const value = this.browserStorage.getUserData(accessTokenKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit", correlationId);
             this.removeAccessTokenKeys([accessTokenKey], correlationId);
             return null;
         }
         const parsedAccessToken = this.validateAndParseJson(value);
         if (!parsedAccessToken ||
             !CacheHelpers.isAccessTokenEntity(parsedAccessToken)) {
-            this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getAccessTokenCredential: cache hit");
+        this.logger.trace("BrowserCacheManager.getAccessTokenCredential: cache hit", correlationId);
         return parsedAccessToken;
     }
     /**
@@ -561,7 +546,7 @@ class BrowserCacheManager extends CacheManager {
      * @param accessToken
      */
     async setAccessTokenCredential(accessToken, correlationId) {
-        this.logger.trace("BrowserCacheManager.setAccessTokenCredential called");
+        this.logger.trace("BrowserCacheManager.setAccessTokenCredential called", correlationId);
         const accessTokenKey = this.generateCredentialKey(accessToken);
         const timestamp = Date.now().toString();
         accessToken.lastUpdatedAt = timestamp;
@@ -571,7 +556,7 @@ class BrowserCacheManager extends CacheManager {
         if (index !== -1) {
             tokenKeys.accessToken.splice(index, 1); // Remove existing key before pushing to the end
         }
-        this.logger.trace(`access token ${index === -1 ? "added to" : "updated in"} map`);
+        this.logger.trace(`access token '${index === -1 ? "added to" : "updated in"}' map`, correlationId);
         tokenKeys.accessToken.push(accessTokenKey);
         this.setTokenKeys(tokenKeys, correlationId);
     }
@@ -582,17 +567,17 @@ class BrowserCacheManager extends CacheManager {
     getRefreshTokenCredential(refreshTokenKey, correlationId) {
         const value = this.browserStorage.getUserData(refreshTokenKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit", correlationId);
             this.removeRefreshToken(refreshTokenKey, correlationId);
             return null;
         }
         const parsedRefreshToken = this.validateAndParseJson(value);
         if (!parsedRefreshToken ||
             !CacheHelpers.isRefreshTokenEntity(parsedRefreshToken)) {
-            this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: cache hit");
+        this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: cache hit", correlationId);
         return parsedRefreshToken;
     }
     /**
@@ -600,14 +585,14 @@ class BrowserCacheManager extends CacheManager {
      * @param refreshToken
      */
     async setRefreshTokenCredential(refreshToken, correlationId) {
-        this.logger.trace("BrowserCacheManager.setRefreshTokenCredential called");
+        this.logger.trace("BrowserCacheManager.setRefreshTokenCredential called", correlationId);
         const refreshTokenKey = this.generateCredentialKey(refreshToken);
         const timestamp = Date.now().toString();
         refreshToken.lastUpdatedAt = timestamp;
         await this.setUserData(refreshTokenKey, JSON.stringify(refreshToken), correlationId, timestamp);
         const tokenKeys = this.getTokenKeys();
         if (tokenKeys.refreshToken.indexOf(refreshTokenKey) === -1) {
-            this.logger.info("BrowserCacheManager: addTokenKey - refreshToken added to map");
+            this.logger.info("BrowserCacheManager: addTokenKey - refreshToken added to map", correlationId);
             tokenKeys.refreshToken.push(refreshTokenKey);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -615,48 +600,51 @@ class BrowserCacheManager extends CacheManager {
     /**
      * fetch appMetadata entity from the platform cache
      * @param appMetadataKey
+     * @param correlationId
      */
-    getAppMetadata(appMetadataKey) {
+    getAppMetadata(appMetadataKey, correlationId) {
         const value = this.browserStorage.getItem(appMetadataKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getAppMetadata: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getAppMetadata: called, no cache hit", correlationId);
             return null;
         }
         const parsedMetadata = this.validateAndParseJson(value);
         if (!parsedMetadata ||
             !CacheHelpers.isAppMetadataEntity(appMetadataKey, parsedMetadata)) {
-            this.logger.trace("BrowserCacheManager.getAppMetadata: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getAppMetadata: called, no cache hit", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getAppMetadata: cache hit");
+        this.logger.trace("BrowserCacheManager.getAppMetadata: cache hit", correlationId);
         return parsedMetadata;
     }
     /**
      * set appMetadata entity to the platform cache
      * @param appMetadata
+     * @param correlationId
      */
     setAppMetadata(appMetadata, correlationId) {
-        this.logger.trace("BrowserCacheManager.setAppMetadata called");
+        this.logger.trace("BrowserCacheManager.setAppMetadata called", correlationId);
         const appMetadataKey = CacheHelpers.generateAppMetadataKey(appMetadata);
         this.setItem(appMetadataKey, JSON.stringify(appMetadata), correlationId);
     }
     /**
      * fetch server telemetry entity from the platform cache
      * @param serverTelemetryKey
+     * @param correlationId
      */
-    getServerTelemetry(serverTelemetryKey) {
+    getServerTelemetry(serverTelemetryKey, correlationId) {
         const value = this.browserStorage.getItem(serverTelemetryKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getServerTelemetry: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getServerTelemetry: called, no cache hit", correlationId);
             return null;
         }
         const parsedEntity = this.validateAndParseJson(value);
         if (!parsedEntity ||
             !CacheHelpers.isServerTelemetryEntity(serverTelemetryKey, parsedEntity)) {
-            this.logger.trace("BrowserCacheManager.getServerTelemetry: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getServerTelemetry: called, no cache hit", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getServerTelemetry: cache hit");
+        this.logger.trace("BrowserCacheManager.getServerTelemetry: cache hit", correlationId);
         return parsedEntity;
     }
     /**
@@ -665,22 +653,22 @@ class BrowserCacheManager extends CacheManager {
      * @param serverTelemetry
      */
     setServerTelemetry(serverTelemetryKey, serverTelemetry, correlationId) {
-        this.logger.trace("BrowserCacheManager.setServerTelemetry called");
+        this.logger.trace("BrowserCacheManager.setServerTelemetry called", correlationId);
         this.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry), correlationId);
     }
     /**
      *
      */
-    getAuthorityMetadata(key) {
+    getAuthorityMetadata(key, correlationId) {
         const value = this.internalStorage.getItem(key);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getAuthorityMetadata: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getAuthorityMetadata: called, no cache hit", correlationId);
             return null;
         }
         const parsedMetadata = this.validateAndParseJson(value);
         if (parsedMetadata &&
             CacheHelpers.isAuthorityMetadataEntity(key, parsedMetadata)) {
-            this.logger.trace("BrowserCacheManager.getAuthorityMetadata: cache hit");
+            this.logger.trace("BrowserCacheManager.getAuthorityMetadata: cache hit", correlationId);
             return parsedMetadata;
         }
         return null;
@@ -707,40 +695,40 @@ class BrowserCacheManager extends CacheManager {
      * Returns wrapper metadata from in-memory storage
      */
     getWrapperMetadata() {
-        const sku = this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_SKU) ||
-            Constants.EMPTY_STRING;
-        const version = this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_VER) ||
-            Constants.EMPTY_STRING;
+        const sku = this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_SKU) || "";
+        const version = this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_VER) || "";
         return [sku, version];
     }
     /**
      *
+     * @param key
      * @param entity
+     * @param correlationId
      */
-    setAuthorityMetadata(key, entity) {
-        this.logger.trace("BrowserCacheManager.setAuthorityMetadata called");
+    setAuthorityMetadata(key, entity, correlationId) {
+        this.logger.trace("BrowserCacheManager.setAuthorityMetadata called", correlationId);
         this.internalStorage.setItem(key, JSON.stringify(entity));
     }
     /**
      * Gets the active account
      */
     getActiveAccount(correlationId) {
-        const activeAccountKeyFilters = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
+        const activeAccountKeyFilters = this.generateCacheKey(Constants.PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
         const activeAccountValueFilters = this.browserStorage.getItem(activeAccountKeyFilters);
         if (!activeAccountValueFilters) {
-            this.logger.trace("BrowserCacheManager.getActiveAccount: No active account filters found");
+            this.logger.trace("BrowserCacheManager.getActiveAccount: No active account filters found", correlationId);
             return null;
         }
         const activeAccountValueObj = this.validateAndParseJson(activeAccountValueFilters);
         if (activeAccountValueObj) {
-            this.logger.trace("BrowserCacheManager.getActiveAccount: Active account filters schema found");
+            this.logger.trace("BrowserCacheManager.getActiveAccount: Active account filters schema found", correlationId);
             return this.getAccountInfoFilteredBy({
                 homeAccountId: activeAccountValueObj.homeAccountId,
                 localAccountId: activeAccountValueObj.localAccountId,
                 tenantId: activeAccountValueObj.tenantId,
             }, correlationId);
         }
-        this.logger.trace("BrowserCacheManager.getActiveAccount: No active account found");
+        this.logger.trace("BrowserCacheManager.getActiveAccount: No active account found", correlationId);
         return null;
     }
     /**
@@ -748,19 +736,18 @@ class BrowserCacheManager extends CacheManager {
      * @param account
      */
     setActiveAccount(account, correlationId) {
-        const activeAccountKey = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
+        const activeAccountKey = this.generateCacheKey(Constants.PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
         if (account) {
-            this.logger.verbose("setActiveAccount: Active account set");
+            this.logger.verbose("setActiveAccount: Active account set", correlationId);
             const activeAccountValue = {
                 homeAccountId: account.homeAccountId,
                 localAccountId: account.localAccountId,
                 tenantId: account.tenantId,
-                lastUpdatedAt: TimeUtils.nowSeconds().toString(),
             };
             this.setItem(activeAccountKey, JSON.stringify(activeAccountValue), correlationId);
         }
         else {
-            this.logger.verbose("setActiveAccount: No account passed, active account not set");
+            this.logger.verbose("setActiveAccount: No account passed, active account not set", correlationId);
             this.browserStorage.removeItem(activeAccountKey);
         }
         this.eventHandler.emitEvent(EventType.ACTIVE_ACCOUNT_CHANGED);
@@ -768,20 +755,21 @@ class BrowserCacheManager extends CacheManager {
     /**
      * fetch throttling entity from the platform cache
      * @param throttlingCacheKey
+     * @param correlationId
      */
-    getThrottlingCache(throttlingCacheKey) {
+    getThrottlingCache(throttlingCacheKey, correlationId) {
         const value = this.browserStorage.getItem(throttlingCacheKey);
         if (!value) {
-            this.logger.trace("BrowserCacheManager.getThrottlingCache: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getThrottlingCache: called, no cache hit", correlationId);
             return null;
         }
         const parsedThrottlingCache = this.validateAndParseJson(value);
         if (!parsedThrottlingCache ||
             !CacheHelpers.isThrottlingEntity(throttlingCacheKey, parsedThrottlingCache)) {
-            this.logger.trace("BrowserCacheManager.getThrottlingCache: called, no cache hit");
+            this.logger.trace("BrowserCacheManager.getThrottlingCache: called, no cache hit", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getThrottlingCache: cache hit");
+        this.logger.trace("BrowserCacheManager.getThrottlingCache: cache hit", correlationId);
         return parsedThrottlingCache;
     }
     /**
@@ -790,23 +778,17 @@ class BrowserCacheManager extends CacheManager {
      * @param throttlingCache
      */
     setThrottlingCache(throttlingCacheKey, throttlingCache, correlationId) {
-        this.logger.trace("BrowserCacheManager.setThrottlingCache called");
+        this.logger.trace("BrowserCacheManager.setThrottlingCache called", correlationId);
         this.setItem(throttlingCacheKey, JSON.stringify(throttlingCache), correlationId);
     }
     /**
      * Gets cache item with given key.
-     * Will retrieve from cookies if storeAuthStateInCookie is set to true.
-     * @param key
+     * @param cacheKey
+     * @param correlationId
+     * @param generateKey
      */
-    getTemporaryCache(cacheKey, generateKey) {
+    getTemporaryCache(cacheKey, correlationId, generateKey) {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            const itemCookie = this.cookieStorage.getItem(key);
-            if (itemCookie) {
-                this.logger.trace("BrowserCacheManager.getTemporaryCache: storeAuthStateInCookies set to true, retrieving from cookies");
-                return itemCookie;
-            }
-        }
         const value = this.temporaryCacheStorage.getItem(key);
         if (!value) {
             // If temp cache item not found in session/memory, check local storage for items set by old versions
@@ -814,30 +796,23 @@ class BrowserCacheManager extends CacheManager {
                 BrowserCacheLocation.LocalStorage) {
                 const item = this.browserStorage.getItem(key);
                 if (item) {
-                    this.logger.trace("BrowserCacheManager.getTemporaryCache: Temporary cache item found in local storage");
+                    this.logger.trace("BrowserCacheManager.getTemporaryCache: Temporary cache item found in local storage", correlationId);
                     return item;
                 }
             }
-            this.logger.trace("BrowserCacheManager.getTemporaryCache: No cache item found in local storage");
+            this.logger.trace("BrowserCacheManager.getTemporaryCache: No cache item found in local storage", correlationId);
             return null;
         }
-        this.logger.trace("BrowserCacheManager.getTemporaryCache: Temporary cache item returned");
         return value;
     }
     /**
      * Sets the cache item with the key and value given.
-     * Stores in cookie if storeAuthStateInCookie is set to true.
-     * This can cause cookie overflow if used incorrectly.
      * @param key
      * @param value
      */
     setTemporaryCache(cacheKey, value, generateKey) {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
         this.temporaryCacheStorage.setItem(key, value);
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            this.logger.trace("BrowserCacheManager.setTemporaryCache: storeAuthStateInCookie set to true, setting item cookie");
-            this.cookieStorage.setItem(key, value, undefined, this.cacheConfig.secureCookies);
-        }
     }
     /**
      * Removes the cache item with the given key.
@@ -848,15 +823,10 @@ class BrowserCacheManager extends CacheManager {
     }
     /**
      * Removes the temporary cache item with the given key.
-     * Will also clear the cookie item if storeAuthStateInCookie is set to true.
      * @param key
      */
     removeTemporaryItem(key) {
         this.temporaryCacheStorage.removeItem(key);
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            this.logger.trace("BrowserCacheManager.removeItem: storeAuthStateInCookie is true, clearing item cookie");
-            this.cookieStorage.removeItem(key);
-        }
     }
     /**
      * Gets all keys in window.
@@ -887,30 +857,6 @@ class BrowserCacheManager extends CacheManager {
         });
         this.internalStorage.clear();
     }
-    /**
-     * Clears all access tokes that have claims prior to saving the current one
-     * @param performanceClient {IPerformanceClient}
-     * @param correlationId {string} correlation id
-     * @returns
-     */
-    clearTokensAndKeysWithClaims(correlationId) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.ClearTokensAndKeysWithClaims, correlationId);
-        const tokenKeys = this.getTokenKeys();
-        let removedAccessTokens = 0;
-        tokenKeys.accessToken.forEach((key) => {
-            // if the access token has claims in its key, remove the token key and the token
-            const credential = this.getAccessTokenCredential(key, correlationId);
-            if (credential?.requestedClaimsHash &&
-                key.includes(credential.requestedClaimsHash.toLowerCase())) {
-                this.removeAccessToken(key, correlationId);
-                removedAccessTokens++;
-            }
-        });
-        // warn if any access tokens are removed
-        if (removedAccessTokens > 0) {
-            this.logger.warning(`${removedAccessTokens} access tokens with claims in the cache keys have been removed from the cache.`);
-        }
-    }
     /**
      * Prepend msal.<client-id> to each key
      * @param key
@@ -931,12 +877,13 @@ class BrowserCacheManager extends CacheManager {
      * @returns
      */
     generateCredentialKey(credential) {
-        const familyId = (credential.credentialType === CredentialType.REFRESH_TOKEN &&
+        const familyId = (credential.credentialType ===
+            Constants.CredentialType.REFRESH_TOKEN &&
             credential.familyId) ||
             credential.clientId;
         const scheme = credential.tokenType &&
             credential.tokenType.toLowerCase() !==
-                AuthenticationScheme.BEARER.toLowerCase()
+                Constants.AuthenticationScheme.BEARER.toLowerCase()
             ? credential.tokenType.toLowerCase()
             : "";
         const credentialKey = [
@@ -947,7 +894,6 @@ class BrowserCacheManager extends CacheManager {
             familyId,
             credential.realm || "",
             credential.target || "",
-            credential.requestedClaimsHash || "",
             scheme,
         ];
         return credentialKey.join(CACHE_KEY_SEPARATOR).toLowerCase();
@@ -969,19 +915,19 @@ class BrowserCacheManager extends CacheManager {
     }
     /**
      * Reset all temporary cache items
-     * @param state
+     * @param correlationId
      */
-    resetRequestCache() {
-        this.logger.trace("BrowserCacheManager.resetRequestCache called");
+    resetRequestCache(correlationId) {
+        this.logger.trace("BrowserCacheManager.resetRequestCache called", correlationId);
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.REQUEST_PARAMS));
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.VERIFIER));
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.ORIGIN_URI));
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.URL_HASH));
         this.removeTemporaryItem(this.generateCacheKey(TemporaryCacheKeys.NATIVE_REQUEST));
-        this.setInteractionInProgress(false);
+        this.setInteractionInProgress(false, undefined);
     }
-    cacheAuthorizeRequest(authCodeRequest, codeVerifier) {
-        this.logger.trace("BrowserCacheManager.cacheAuthorizeRequest called");
+    cacheAuthorizeRequest(authCodeRequest, correlationId, codeVerifier) {
+        this.logger.trace("BrowserCacheManager.cacheAuthorizeRequest called", correlationId);
         const encodedValue = base64Encode(JSON.stringify(authCodeRequest));
         this.setTemporaryCache(TemporaryCacheKeys.REQUEST_PARAMS, encodedValue, true);
         if (codeVerifier) {
@@ -991,15 +937,16 @@ class BrowserCacheManager extends CacheManager {
     }
     /**
      * Gets the token exchange parameters from the cache. Throws an error if nothing is found.
+     * @param correlationId
      */
-    getCachedRequest() {
-        this.logger.trace("BrowserCacheManager.getCachedRequest called");
+    getCachedRequest(correlationId) {
+        this.logger.trace("BrowserCacheManager.getCachedRequest called", correlationId);
         // Get token request from cache and parse as TokenExchangeParameters.
-        const encodedTokenRequest = this.getTemporaryCache(TemporaryCacheKeys.REQUEST_PARAMS, true);
+        const encodedTokenRequest = this.getTemporaryCache(TemporaryCacheKeys.REQUEST_PARAMS, correlationId, true);
         if (!encodedTokenRequest) {
             throw createBrowserAuthError(noTokenRequestCacheError);
         }
-        const encodedVerifier = this.getTemporaryCache(TemporaryCacheKeys.VERIFIER, true);
+        const encodedVerifier = this.getTemporaryCache(TemporaryCacheKeys.VERIFIER, correlationId, true);
         let parsedRequest;
         let verifier = "";
         try {
@@ -1009,25 +956,26 @@ class BrowserCacheManager extends CacheManager {
             }
         }
         catch (e) {
-            this.logger.errorPii(`Attempted to parse: ${encodedTokenRequest}`);
-            this.logger.error(`Parsing cached token request threw with error: ${e}`);
+            this.logger.errorPii(`Attempted to parse: '${encodedTokenRequest}'`, correlationId);
+            this.logger.error(`Parsing cached token request threw with error: '${e}'`, correlationId);
             throw createBrowserAuthError(unableToParseTokenRequestCacheError);
         }
         return [parsedRequest, verifier];
     }
     /**
      * Gets cached native request for redirect flows
+     * @param correlationId
      */
     getCachedNativeRequest() {
-        this.logger.trace("BrowserCacheManager.getCachedNativeRequest called");
-        const cachedRequest = this.getTemporaryCache(TemporaryCacheKeys.NATIVE_REQUEST, true);
+        this.logger.trace("BrowserCacheManager.getCachedNativeRequest called", "");
+        const cachedRequest = this.getTemporaryCache(TemporaryCacheKeys.NATIVE_REQUEST, "", true);
         if (!cachedRequest) {
-            this.logger.trace("BrowserCacheManager.getCachedNativeRequest: No cached native request found");
+            this.logger.trace("BrowserCacheManager.getCachedNativeRequest: No cached native request found", "");
             return null;
         }
         const parsedRequest = this.validateAndParseJson(cachedRequest);
         if (!parsedRequest) {
-            this.logger.error("BrowserCacheManager.getCachedNativeRequest: Unable to parse native request");
+            this.logger.error("BrowserCacheManager.getCachedNativeRequest: Unable to parse native request", "");
             return null;
         }
         return parsedRequest;
@@ -1043,15 +991,15 @@ class BrowserCacheManager extends CacheManager {
     }
     getInteractionInProgress() {
         const key = `${PREFIX}.${TemporaryCacheKeys.INTERACTION_STATUS_KEY}`;
-        const value = this.getTemporaryCache(key, false);
+        const value = this.getTemporaryCache(key, "", false);
         try {
             return value ? JSON.parse(value) : null;
         }
         catch (e) {
             // Remove interaction and other temp keys if interaction status can't be parsed
-            this.logger.error(`Cannot parse interaction status. Removing temporary cache items and clearing url hash. Retrying interaction should fix the error`);
+            this.logger.error(`Cannot parse interaction status. Removing temporary cache items and clearing url hash. Retrying interaction should fix the error`, "");
             this.removeTemporaryItem(key);
-            this.resetRequestCache();
+            this.resetRequestCache("");
             clearHash(window);
             return null;
         }
@@ -1080,10 +1028,6 @@ class BrowserCacheManager extends CacheManager {
      */
     async hydrateCache(result, request) {
         const idTokenEntity = CacheHelpers.createIdTokenEntity(result.account?.homeAccountId, result.account?.environment, result.idToken, this.clientId, result.tenantId);
-        let claimsHash;
-        if (request.claims) {
-            claimsHash = await this.cryptoImpl.hashString(request.claims);
-        }
         /**
          * meta data for cache stores time in seconds from epoch
          * AuthenticationResult returns expiresOn and extExpiresOn in milliseconds (as a Date object which is in ms)
@@ -1099,7 +1043,7 @@ class BrowserCacheManager extends CacheManager {
             ? TimeUtils.toSecondsFromDate(result.extExpiresOn)
             : 0, base64Decode, undefined, // refreshOn
         result.tokenType, undefined, // userAssertionHash
-        request.sshKid, request.claims, claimsHash);
+        request.sshKid);
         const cacheRecord = {
             idToken: idTokenEntity,
             accessToken: accessTokenEntity,
@@ -1151,7 +1095,7 @@ function getStorageImplementation(clientId, cacheLocation, logger, performanceCl
         }
     }
     catch (e) {
-        logger.error(e);
+        logger.error(e, "");
     }
     return new MemoryStorage();
 }
@@ -1159,11 +1103,6 @@ const DEFAULT_BROWSER_CACHE_MANAGER = (clientId, logger, performanceClient, even
     const cacheOptions = {
         cacheLocation: BrowserCacheLocation.MemoryStorage,
         cacheRetentionDays: 5,
-        temporaryCacheLocation: BrowserCacheLocation.MemoryStorage,
-        storeAuthStateInCookie: false,
-        secureCookies: false,
-        cacheMigrationEnabled: false,
-        claimsBasedCachingEnabled: false,
     };
     return new BrowserCacheManager(clientId, cacheOptions, DEFAULT_CRYPTO_IMPLEMENTATION, logger, performanceClient, eventHandler);
 };