plugin-data-source-mssql 2.0.5 → 2.0.7

package/dist/tedious/node_modules/@azure/msal-browser/dist/custom-auth-path/controllers/StandardController.mjs

@@ -1,18 +1,21 @@
-/*! @azure/msal-browser v4.28.2 2026-02-10 */
+/*! @azure/msal-browser v5.8.0 2026-04-21 */
 'use strict';
 import { CryptoOps } from '../crypto/CryptoOps.mjs';
-import { DEFAULT_CRYPTO_IMPLEMENTATION, buildStaticAuthorityOptions, PerformanceEvents, invokeAsync, invoke, InteractionRequiredAuthError, createClientAuthError, ClientAuthErrorCodes, AccountEntity, AuthToken, PromptValue, Constants, AuthError, getRequestThumbprint, InteractionRequiredAuthErrorCodes } from '@azure/msal-common/browser';
+import { DEFAULT_CRYPTO_IMPLEMENTATION, buildStaticAuthorityOptions, invokeAsync, enforceResourceParameter, InteractionRequiredAuthError, createClientAuthError, ClientAuthErrorCodes, AccountEntityUtils, AuthToken, CacheHelpers, TimeUtils, Constants, AuthError, getRequestThumbprint, InteractionRequiredAuthErrorCodes } from '@azure/msal-common/browser';
+import { InitializeCache, HandleNativeRedirectPromiseMeasurement, HandleRedirectPromiseMeasurement, NativeInteractionClientAcquireTokenRedirect, AcquireTokenByCodeAsync, SilentCacheClientAcquireToken, SilentRefreshClientAcquireToken, SilentIframeClientAcquireToken, NativeInteractionClientAcquireToken, AcquireTokenSilentAsync, InitializeSilentRequest, AcquireTokenBySilentIframe, AwaitConcurrentIframe, AcquireTokenFromCache, AcquireTokenByRefreshToken, GeneratePkceCodes } from '../telemetry/BrowserPerformanceEvents.mjs';
+import { InitializeClientApplication, AcquireTokenRedirect, AcquireTokenPreRedirect, AcquireTokenPopup, SsoCapable, SsoSilent, AcquireTokenByCode, AcquireTokenSilent } from '../telemetry/BrowserRootPerformanceEvents.mjs';
 import { BrowserCacheManager, DEFAULT_BROWSER_CACHE_MANAGER } from '../cache/BrowserCacheManager.mjs';
-import { getAllAccounts, getAccount, getAccountByUsername, getAccountByHomeId, getAccountByLocalId, setActiveAccount, getActiveAccount } from '../cache/AccountManager.mjs';
+import { SSO_CAPABLE } from '../cache/CacheKeys.mjs';
+import { getAllAccounts, getAccount, setActiveAccount, getActiveAccount } from '../cache/AccountManager.mjs';
 import { BrowserCacheLocation, INTERACTION_TYPE, InteractionType, ApiId, CacheLookupPolicy, DEFAULT_REQUEST, iFrameRenewalPolicies, BrowserConstants } from '../utils/BrowserConstants.mjs';
 import { blockAPICallsBeforeInitialize, redirectPreflightCheck, preflightCheck as preflightCheck$1, blockNonBrowserEnvironment } from '../utils/BrowserUtils.mjs';
 import { EventType } from '../event/EventType.mjs';
 import { EventHandler } from '../event/EventHandler.mjs';
+import { base64Decode } from '../encode/Base64Decode.mjs';
 import { PopupClient } from '../interaction_client/PopupClient.mjs';
 import { RedirectClient } from '../interaction_client/RedirectClient.mjs';
 import { SilentIframeClient } from '../interaction_client/SilentIframeClient.mjs';
 import { SilentRefreshClient } from '../interaction_client/SilentRefreshClient.mjs';
-import { TokenCache } from '../cache/TokenCache.mjs';
 import { PlatformAuthInteractionClient } from '../interaction_client/PlatformAuthInteractionClient.mjs';
 import { NativeAuthError, isFatalNativeAuthError } from '../error/NativeAuthError.mjs';
 import { SilentCacheClient } from '../interaction_client/SilentCacheClient.mjs';
@@ -29,12 +32,13 @@ import { spaCodeAndNativeAccountIdPresent, unableToAcquireTokenFromNativePlatfor
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-function preflightCheck(initialized, performanceEvent, account) {
+function preflightCheck(initialized, performanceEvent, config, request) {
     try {
         preflightCheck$1(initialized);
+        enforceResourceParameter(config.auth.isMcp, request);
     }
     catch (e) {
-        performanceEvent.end({ success: false }, e, account);
+        performanceEvent.end({ success: false }, e, request.account);
         throw e;
     }
 }
@@ -92,79 +96,78 @@ class StandardController {
         const nativeCacheOptions = {
             cacheLocation: BrowserCacheLocation.MemoryStorage,
             cacheRetentionDays: 5,
-            temporaryCacheLocation: BrowserCacheLocation.MemoryStorage,
-            storeAuthStateInCookie: false,
-            secureCookies: false,
-            cacheMigrationEnabled: false,
-            claimsBasedCachingEnabled: false,
         };
         this.nativeInternalStorage = new BrowserCacheManager(this.config.auth.clientId, nativeCacheOptions, this.browserCrypto, this.logger, this.performanceClient, this.eventHandler);
-        // Initialize the token cache
-        this.tokenCache = new TokenCache(this.config, this.browserStorage, this.logger, this.browserCrypto, this.performanceClient);
         this.activeSilentTokenRequests = new Map();
         // Register listener functions
-        this.trackPageVisibility = this.trackPageVisibility.bind(this);
+        this.trackStateChange = this.trackStateChange.bind(this);
         // Register listener functions
-        this.trackPageVisibilityWithMeasurement =
-            this.trackPageVisibilityWithMeasurement.bind(this);
+        this.trackStateChangeWithMeasurement =
+            this.trackStateChangeWithMeasurement.bind(this);
     }
     static async createController(operatingContext, request) {
         const controller = new StandardController(operatingContext);
         await controller.initialize(request);
         return controller;
     }
-    trackPageVisibility(correlationId) {
+    trackStateChange(correlationId, event) {
         if (!correlationId) {
             return;
         }
-        this.logger.info("Perf: Visibility change detected");
-        this.performanceClient.incrementFields({ visibilityChangeCount: 1 }, correlationId);
+        if (event.type === "visibilitychange") {
+            this.logger.info("16v6hv", correlationId);
+            this.performanceClient.incrementFields({ visibilityChangeCount: 1 }, correlationId);
+        }
+        else if (event.type === "online") {
+            this.logger.info("0zirfd", correlationId);
+            this.performanceClient.incrementFields({ onlineStatusChangeCount: 1 }, correlationId);
+        }
+        else if (event.type === "offline") {
+            this.logger.info("1xk9ef", correlationId);
+            this.performanceClient.incrementFields({ onlineStatusChangeCount: 1 }, correlationId);
+        }
     }
     /**
      * Initializer function to perform async startup tasks such as connecting to WAM extension
      * @param request {?InitializeApplicationRequest} correlation id
      */
-    async initialize(request, isBroker) {
-        this.logger.trace("initialize called");
+    async initialize(request) {
+        const correlationId = this.getRequestCorrelationId(request);
+        this.logger.trace("1f7joy", correlationId);
         if (this.initialized) {
-            this.logger.info("initialize has already been called, exiting early.");
+            this.logger.info("061m5x", correlationId);
             return;
         }
         if (!this.isBrowserEnvironment) {
-            this.logger.info("in non-browser environment, exiting early.");
+            this.logger.info("19fvpi", correlationId);
             this.initialized = true;
-            this.eventHandler.emitEvent(EventType.INITIALIZE_END);
+            this.eventHandler.emitEvent(EventType.INITIALIZE_END, correlationId);
             return;
         }
-        const initCorrelationId = request?.correlationId || this.getRequestCorrelationId();
         const allowPlatformBroker = this.config.system.allowPlatformBroker;
-        const initMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.InitializeClientApplication, initCorrelationId);
-        this.eventHandler.emitEvent(EventType.INITIALIZE_START);
+        const initMeasurement = this.performanceClient.startMeasurement(InitializeClientApplication, correlationId);
+        this.eventHandler.emitEvent(EventType.INITIALIZE_START, correlationId);
         // Broker applications are initialized twice, so we avoid double-counting it
-        if (!isBroker) {
-            try {
-                this.logMultipleInstances(initMeasurement);
-            }
-            catch { }
-        }
-        await invokeAsync(this.browserStorage.initialize.bind(this.browserStorage), PerformanceEvents.InitializeCache, this.logger, this.performanceClient, initCorrelationId)(initCorrelationId);
+        this.logMultipleInstances(initMeasurement, correlationId);
+        initMeasurement.add({ isMcp: this.config.auth.isMcp });
+        await invokeAsync(this.browserStorage.initialize.bind(this.browserStorage), InitializeCache, this.logger, this.performanceClient, correlationId)(correlationId);
         if (allowPlatformBroker) {
             try {
                 // check if platform authentication is available via DOM or browser extension and create relevant handlers
-                this.platformAuthProvider = await getPlatformAuthProvider(this.logger, this.performanceClient, initCorrelationId, this.config.system.nativeBrokerHandshakeTimeout, this.config.system.allowPlatformBrokerWithDOM);
+                this.platformAuthProvider = await getPlatformAuthProvider(this.logger, this.performanceClient, correlationId, this.config.system.nativeBrokerHandshakeTimeout);
             }
             catch (e) {
-                this.logger.verbose(e);
+                this.logger.verbose(e, correlationId);
             }
         }
-        if (!this.config.cache.claimsBasedCachingEnabled) {
-            this.logger.verbose("Claims-based caching is disabled. Clearing the previous cache with claims");
-            invoke(this.browserStorage.clearTokensAndKeysWithClaims.bind(this.browserStorage), PerformanceEvents.ClearTokensAndKeysWithClaims, this.logger, this.performanceClient, initCorrelationId)(initCorrelationId);
+        if (this.config.cache.cacheLocation ===
+            BrowserCacheLocation.LocalStorage) {
+            this.eventHandler.subscribeCrossTab();
         }
-        this.config.system.asyncPopups &&
-            (await this.preGeneratePkceCodes(initCorrelationId));
+        !this.config.system.navigatePopups &&
+            (await this.preGeneratePkceCodes(correlationId));
         this.initialized = true;
-        this.eventHandler.emitEvent(EventType.INITIALIZE_END);
+        this.eventHandler.emitEvent(EventType.INITIALIZE_END, correlationId);
         initMeasurement.end({
             allowPlatformBroker: allowPlatformBroker,
             success: true,
@@ -176,10 +179,11 @@ class StandardController {
      * has loaded during redirect flows. This should be invoked on all page loads involved in redirect
      * auth flows.
      * @param hash Hash to process. Defaults to the current value of window.location.hash. Only needs to be provided explicitly if the response to be handled is not contained in the current value.
+     * @param options Object containing optional configuration for redirect promise handling.
      * @returns Token response or null. If the return value is null, then no auth redirect was detected.
      */
-    async handleRedirectPromise(hash) {
-        this.logger.verbose("handleRedirectPromise called");
+    async handleRedirectPromise(options) {
+        this.logger.verbose("02l8bm", "");
         // Block token acquisition before initialize has been called
         blockAPICallsBeforeInitialize(this.initialized);
         if (this.isBrowserEnvironment) {
@@ -188,19 +192,19 @@ class StandardController {
              * otherwise return the promise from the first invocation. Prevents race conditions when handleRedirectPromise is called
              * several times concurrently.
              */
-            const redirectResponseKey = hash || "";
+            const redirectResponseKey = options?.hash || "";
             let response = this.redirectResponse.get(redirectResponseKey);
             if (typeof response === "undefined") {
-                response = this.handleRedirectPromiseInternal(hash);
+                response = this.handleRedirectPromiseInternal(options);
                 this.redirectResponse.set(redirectResponseKey, response);
-                this.logger.verbose("handleRedirectPromise has been called for the first time, storing the promise");
+                this.logger.verbose("1wn9kp", "");
             }
             else {
-                this.logger.verbose("handleRedirectPromise has been called previously, returning the result from the first call");
+                this.logger.verbose("0w0gm3", "");
             }
             return response;
         }
-        this.logger.verbose("handleRedirectPromise returns null, not browser environment");
+        this.logger.verbose("12xi63", "");
         return null;
     }
     /**
@@ -208,64 +212,68 @@ class StandardController {
      * @param hash
      * @returns
      */
-    async handleRedirectPromiseInternal(hash) {
+    async handleRedirectPromiseInternal(options) {
         if (!this.browserStorage.isInteractionInProgress(true)) {
-            this.logger.info("handleRedirectPromise called but there is no interaction in progress, returning null.");
+            this.logger.info("0le6uv", "");
             return null;
         }
         const interactionType = this.browserStorage.getInteractionInProgress()?.type;
         if (interactionType === INTERACTION_TYPE.SIGNOUT) {
-            this.logger.verbose("handleRedirectPromise removing interaction_in_progress flag and returning null after sign-out");
+            this.logger.verbose("1ywcv2", "");
             this.browserStorage.setInteractionInProgress(false);
             return Promise.resolve(null);
         }
         const loggedInAccounts = this.getAllAccounts();
         const platformBrokerRequest = this.browserStorage.getCachedNativeRequest();
-        const useNative = platformBrokerRequest && this.platformAuthProvider && !hash;
+        const useNative = platformBrokerRequest && !options?.hash;
         let rootMeasurement;
-        this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_START, InteractionType.Redirect);
         let redirectResponse;
+        let cachedRedirectRequest;
         try {
             if (useNative && this.platformAuthProvider) {
-                rootMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenRedirect, platformBrokerRequest?.correlationId || "");
-                this.logger.trace("handleRedirectPromise - acquiring token from native platform");
+                const correlationId = platformBrokerRequest?.correlationId || "";
+                this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_START, correlationId, InteractionType.Redirect);
+                rootMeasurement = this.performanceClient.startMeasurement(AcquireTokenRedirect, correlationId);
+                this.logger.trace("12v7is", correlationId);
                 rootMeasurement.add({
                     isPlatformBrokerRequest: true,
                 });
                 const nativeClient = new PlatformAuthInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.handleRedirectPromise, this.performanceClient, this.platformAuthProvider, platformBrokerRequest.accountId, this.nativeInternalStorage, platformBrokerRequest.correlationId);
-                redirectResponse = invokeAsync(nativeClient.handleRedirectPromise.bind(nativeClient), PerformanceEvents.HandleNativeRedirectPromiseMeasurement, this.logger, this.performanceClient, rootMeasurement.event.correlationId)(this.performanceClient, rootMeasurement.event.correlationId);
+                redirectResponse = invokeAsync(nativeClient.handleRedirectPromise.bind(nativeClient), HandleNativeRedirectPromiseMeasurement, this.logger, this.performanceClient, rootMeasurement.event.correlationId)();
             }
             else {
-                const [standardRequest, codeVerifier] = this.browserStorage.getCachedRequest();
+                const [standardRequest, codeVerifier] = this.browserStorage.getCachedRequest("");
+                cachedRedirectRequest = standardRequest;
                 const correlationId = standardRequest.correlationId;
+                this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_START, correlationId, InteractionType.Redirect);
                 // Reset rootMeasurement now that we have correlationId
-                rootMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenRedirect, correlationId);
-                this.logger.trace("handleRedirectPromise - acquiring token from web flow");
+                rootMeasurement = this.performanceClient.startMeasurement(AcquireTokenRedirect, correlationId);
+                this.logger.trace("0znzs5", correlationId);
                 const redirectClient = this.createRedirectClient(correlationId);
-                redirectResponse = invokeAsync(redirectClient.handleRedirectPromise.bind(redirectClient), PerformanceEvents.HandleRedirectPromiseMeasurement, this.logger, this.performanceClient, rootMeasurement.event.correlationId)(hash, standardRequest, codeVerifier, rootMeasurement);
+                redirectResponse = invokeAsync(redirectClient.handleRedirectPromise.bind(redirectClient), HandleRedirectPromiseMeasurement, this.logger, this.performanceClient, rootMeasurement.event.correlationId)(standardRequest, codeVerifier, rootMeasurement, options);
             }
         }
         catch (e) {
-            this.browserStorage.resetRequestCache();
+            this.browserStorage.resetRequestCache("");
             throw e;
         }
         return redirectResponse
             .then((result) => {
             if (result) {
-                this.browserStorage.resetRequestCache();
+                this.browserStorage.resetRequestCache(result.correlationId);
+                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, result.correlationId, InteractionType.Redirect, result);
+                this.logger.verbose("0ui8f5", result.correlationId);
                 // Emit login event if number of accounts change
                 const isLoggingIn = loggedInAccounts.length < this.getAllAccounts().length;
                 if (isLoggingIn) {
-                    this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Redirect, result);
-                    this.logger.verbose("handleRedirectResponse returned result, login success");
-                }
-                else {
-                    this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Redirect, result);
-                    this.logger.verbose("handleRedirectResponse returned result, acquire token success");
+                    this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, result.correlationId, InteractionType.Redirect, result.account);
+                    this.logger.verbose("16im3l", result.correlationId);
                 }
                 rootMeasurement.end({
                     success: true,
                 }, undefined, result.account);
+                // Fire-and-forget SSO capability verification in background
+                this.verifySsoCapability(cachedRedirectRequest, InteractionType.Redirect);
             }
             else {
                 /*
@@ -279,20 +287,14 @@ class StandardController {
                     rootMeasurement.discard();
                 }
             }
-            this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_END, InteractionType.Redirect);
+            this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_END, rootMeasurement.event.correlationId, InteractionType.Redirect);
             return result;
         })
             .catch((e) => {
-            this.browserStorage.resetRequestCache();
+            this.browserStorage.resetRequestCache(rootMeasurement.event.correlationId);
             const eventError = e;
-            // Emit login event if there is an account
-            if (loggedInAccounts.length > 0) {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Redirect, null, eventError);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.LOGIN_FAILURE, InteractionType.Redirect, null, eventError);
-            }
-            this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_END, InteractionType.Redirect);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, rootMeasurement.event.correlationId, InteractionType.Redirect, null, eventError);
+            this.eventHandler.emitEvent(EventType.HANDLE_REDIRECT_END, rootMeasurement.event.correlationId, InteractionType.Redirect);
             rootMeasurement.end({
                 success: false,
             }, eventError);
@@ -311,58 +313,33 @@ class StandardController {
     async acquireTokenRedirect(request) {
         // Preflight request
         const correlationId = this.getRequestCorrelationId(request);
-        this.logger.verbose("acquireTokenRedirect called", correlationId);
-        const atrMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenPreRedirect, correlationId);
+        this.logger.verbose("0os66p", correlationId);
+        const atrMeasurement = this.performanceClient.startMeasurement(AcquireTokenPreRedirect, correlationId);
         atrMeasurement.add({
             scenarioId: request.scenarioId,
         });
-        // Override on request only if set, as onRedirectNavigate field is deprecated
-        const onRedirectNavigateCb = request.onRedirectNavigate;
-        if (onRedirectNavigateCb) {
-            request.onRedirectNavigate = (url) => {
-                const navigate = typeof onRedirectNavigateCb === "function"
-                    ? onRedirectNavigateCb(url)
-                    : undefined;
-                atrMeasurement.add({
-                    navigateCallbackResult: navigate !== false,
-                });
-                atrMeasurement.event =
-                    atrMeasurement.end({ success: true }, undefined, request.account) || atrMeasurement.event;
-                return navigate;
-            };
-        }
-        else {
-            const configOnRedirectNavigateCb = this.config.auth.onRedirectNavigate;
-            this.config.auth.onRedirectNavigate = (url) => {
-                const navigate = typeof configOnRedirectNavigateCb === "function"
-                    ? configOnRedirectNavigateCb(url)
-                    : undefined;
-                atrMeasurement.add({
-                    navigateCallbackResult: navigate !== false,
-                });
-                atrMeasurement.event =
-                    atrMeasurement.end({ success: true }, undefined, request.account) || atrMeasurement.event;
-                return navigate;
-            };
-        }
-        // If logged in, emit acquire token events
-        const isLoggedIn = this.getAllAccounts().length > 0;
+        const configOnRedirectNavigateCb = this.config.auth.onRedirectNavigate;
+        this.config.auth.onRedirectNavigate = (url) => {
+            const navigate = typeof configOnRedirectNavigateCb === "function"
+                ? configOnRedirectNavigateCb(url)
+                : undefined;
+            atrMeasurement.add({
+                navigateCallbackResult: navigate !== false,
+            });
+            atrMeasurement.event =
+                atrMeasurement.end({ success: true }, undefined, request.account) || atrMeasurement.event;
+            return navigate;
+        };
         try {
             redirectPreflightCheck(this.initialized, this.config);
+            enforceResourceParameter(this.config.auth.isMcp, request);
             this.browserStorage.setInteractionInProgress(true, INTERACTION_TYPE.SIGNIN);
-            if (isLoggedIn) {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Redirect, request);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.LOGIN_START, InteractionType.Redirect, request);
-            }
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, correlationId, InteractionType.Redirect, request);
             let result;
             if (this.platformAuthProvider &&
                 this.canUsePlatformBroker(request)) {
                 const nativeClient = new PlatformAuthInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.acquireTokenRedirect, this.performanceClient, this.platformAuthProvider, this.getNativeAccountId(request), this.nativeInternalStorage, correlationId);
-                result = nativeClient
-                    .acquireTokenRedirect(request, atrMeasurement)
-                    .catch((e) => {
+                result = invokeAsync(nativeClient.acquireTokenRedirect.bind(nativeClient), NativeInteractionClientAcquireTokenRedirect, this.logger, this.performanceClient, correlationId)(request, atrMeasurement).catch((e) => {
                     atrMeasurement.add({
                         brokerErrorName: e.name,
                         brokerErrorCode: e.errorCode,
@@ -374,7 +351,7 @@ class StandardController {
                         return redirectClient.acquireToken(request);
                     }
                     else if (e instanceof InteractionRequiredAuthError) {
-                        this.logger.verbose("acquireTokenRedirect - Resolving interaction required error thrown by native broker by falling back to web flow");
+                        this.logger.verbose("1ipyz4", correlationId);
                         const redirectClient = this.createRedirectClient(correlationId);
                         return redirectClient.acquireToken(request);
                     }
@@ -388,25 +365,20 @@ class StandardController {
             return await result;
         }
         catch (e) {
-            this.browserStorage.resetRequestCache();
+            this.browserStorage.resetRequestCache(correlationId);
             /*
              * Pre-redirect event completes before navigation occurs.
              * Timed out navigation needs to be instrumented separately as a post-redirect event.
              */
             if (atrMeasurement.event.status === 2) {
                 this.performanceClient
-                    .startMeasurement(PerformanceEvents.AcquireTokenRedirect, correlationId)
+                    .startMeasurement(AcquireTokenRedirect, correlationId)
                     .end({ success: false }, e, request.account);
             }
             else {
                 atrMeasurement.end({ success: false }, e, request.account);
             }
-            if (isLoggedIn) {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Redirect, null, e);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.LOGIN_FAILURE, InteractionType.Redirect, null, e);
-            }
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, correlationId, InteractionType.Redirect, null, e);
             throw e;
         }
     }
@@ -421,14 +393,14 @@ class StandardController {
      */
     acquireTokenPopup(request) {
         const correlationId = this.getRequestCorrelationId(request);
-        const atPopupMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenPopup, correlationId);
+        const atPopupMeasurement = this.performanceClient.startMeasurement(AcquireTokenPopup, correlationId);
         atPopupMeasurement.add({
             scenarioId: request.scenarioId,
         });
         try {
-            this.logger.verbose("acquireTokenPopup called", correlationId);
-            preflightCheck(this.initialized, atPopupMeasurement, request.account);
-            this.browserStorage.setInteractionInProgress(true, INTERACTION_TYPE.SIGNIN);
+            this.logger.verbose("0ch87b", correlationId);
+            preflightCheck(this.initialized, atPopupMeasurement, this.config, request);
+            this.browserStorage.setInteractionInProgress(true, INTERACTION_TYPE.SIGNIN, request.overrideInteractionInProgress, correlationId);
         }
         catch (e) {
             // Since this function is syncronous we need to reject
@@ -436,12 +408,7 @@ class StandardController {
         }
         // If logged in, emit acquire token events
         const loggedInAccounts = this.getAllAccounts();
-        if (loggedInAccounts.length > 0) {
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Popup, request);
-        }
-        else {
-            this.eventHandler.emitEvent(EventType.LOGIN_START, InteractionType.Popup, request);
-        }
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, correlationId, InteractionType.Popup, request);
         let result;
         const pkce = this.getPreGeneratedPkceCodes(correlationId);
         if (this.canUsePlatformBroker(request)) {
@@ -455,6 +422,7 @@ class StandardController {
                 .then((response) => {
                 atPopupMeasurement.end({
                     success: true,
+                    isNativeBroker: true,
                 }, undefined, response.account);
                 return response;
             })
@@ -465,12 +433,12 @@ class StandardController {
                 });
                 if (e instanceof NativeAuthError &&
                     isFatalNativeAuthError(e)) {
-                    this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to continuing to attempt platform broker calls
+                    this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt platform broker calls
                     const popupClient = this.createPopupClient(correlationId);
                     return popupClient.acquireToken(request, pkce);
                 }
                 else if (e instanceof InteractionRequiredAuthError) {
-                    this.logger.verbose("acquireTokenPopup - Resolving interaction required error thrown by native broker by falling back to web flow");
+                    this.logger.verbose("0yy5fw", correlationId);
                     const popupClient = this.createPopupClient(correlationId);
                     return popupClient.acquireToken(request, pkce);
                 }
@@ -487,26 +455,21 @@ class StandardController {
              *  If logged in, emit acquire token events
              */
             const isLoggingIn = loggedInAccounts.length < this.getAllAccounts().length;
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, correlationId, InteractionType.Popup, result);
             if (isLoggingIn) {
-                this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, InteractionType.Popup, result);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Popup, result);
+                this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, correlationId, InteractionType.Popup, result.account);
             }
             atPopupMeasurement.end({
                 success: true,
                 accessTokenSize: result.accessToken.length,
                 idTokenSize: result.idToken.length,
             }, undefined, result.account);
+            // SSO capability verification in background
+            this.verifySsoCapability(request, InteractionType.Popup);
             return result;
         })
             .catch((e) => {
-            if (loggedInAccounts.length > 0) {
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Popup, null, e);
-            }
-            else {
-                this.eventHandler.emitEvent(EventType.LOGIN_FAILURE, InteractionType.Popup, null, e);
-            }
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, correlationId, InteractionType.Popup, null, e);
             atPopupMeasurement.end({
                 success: false,
             }, e, request.account);
@@ -515,21 +478,142 @@ class StandardController {
         })
             .finally(async () => {
             this.browserStorage.setInteractionInProgress(false);
-            if (this.config.system.asyncPopups) {
+            if (!this.config.system.navigatePopups) {
                 await this.preGeneratePkceCodes(correlationId);
             }
         });
     }
-    trackPageVisibilityWithMeasurement() {
+    trackStateChangeWithMeasurement(event) {
         const measurement = this.ssoSilentMeasurement ||
             this.acquireTokenByCodeAsyncMeasurement;
         if (!measurement) {
             return;
         }
-        this.logger.info("Perf: Visibility change detected in ", measurement.event.name);
-        measurement.increment({
-            visibilityChangeCount: 1,
+        if (event.type === "visibilitychange") {
+            this.logger.info("0yzimq", measurement.event.correlationId);
+            measurement.increment({
+                visibilityChangeCount: 1,
+            });
+        }
+        else if (event.type === "online") {
+            this.logger.info("1caf53", measurement.event.correlationId);
+            measurement.increment({
+                onlineStatusChangeCount: 1,
+            });
+        }
+        else if (event.type === "offline") {
+            this.logger.info("0fdyk7", measurement.event.correlationId);
+            measurement.increment({
+                onlineStatusChangeCount: 1,
+            });
+        }
+    }
+    addStateChangeListeners(listener) {
+        document.addEventListener("visibilitychange", listener);
+        window.addEventListener("online", listener);
+        window.addEventListener("offline", listener);
+    }
+    removeStateChangeListeners(listener) {
+        document.removeEventListener("visibilitychange", listener);
+        window.removeEventListener("online", listener);
+        window.removeEventListener("offline", listener);
+    }
+    /**
+     * Reads the cached ssoCapable value from localStorage.
+     * @returns The cached ssoCapable boolean value, or undefined if not cached or expired.
+     */
+    getCachedSsoCapable() {
+        try {
+            const cachedValue = window.localStorage.getItem(SSO_CAPABLE);
+            if (cachedValue) {
+                const parsed = JSON.parse(cachedValue);
+                if (parsed &&
+                    typeof parsed.ssoCapable === "boolean" &&
+                    parsed.expiresOn &&
+                    Date.now() < parsed.expiresOn) {
+                    return parsed.ssoCapable;
+                }
+            }
+        }
+        catch {
+            // If parsing fails, return undefined
+        }
+        return undefined;
+    }
+    /**
+     * SSO capability verification in the background.
+     * This method makes an iframe request to /authorize to verify SSO capability without calling /token.
+     * This method does not block the caller and tracks telemetry for success/failure.
+     * This method only executes if verifySSO is set to true in the auth configuration.
+     * The result is cached in localStorage with a 24-hour TTL; the SSO verification call
+     * is only attempted when the cached value is absent or expired.
+     * @param request - The original request used for the authentication flow
+     * @param interactionType - The interactionType of the AT operation for logging purposes
+     */
+    verifySsoCapability(request, interactionType) {
+        // Check if SSO capability verification is enabled
+        if (!this.config.auth.verifySSO) {
+            return;
+        }
+        // Check TTL: derive ssoCapable state from localStorage and skip if not expired
+        const ssoCacheKey = SSO_CAPABLE;
+        const SSO_CAPABLE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+        const cachedSsoCapable = this.getCachedSsoCapable();
+        if (cachedSsoCapable !== undefined) {
+            this.logger.verbose("13poou", "");
+            return;
+        }
+        const correlationId = createNewGuid();
+        const ssoCapableMeasurement = this.performanceClient.startMeasurement(SsoCapable, correlationId);
+        ssoCapableMeasurement.add({
+            "ext.interactionType": interactionType,
         });
+        this.logger.verbose("0pbr0i", correlationId);
+        /*
+         * Use setTimeout to ensure this runs in a separate macrotask after the current call stack completes
+         * This ensures the result is returned to the caller before the SSO verification starts and doesn't affect performance
+         */
+        setTimeout(() => {
+            const ssoVerificationRequest = {
+                ...request,
+                correlationId: correlationId,
+            };
+            const silentIframeClient = this.createSilentIframeClient(correlationId);
+            silentIframeClient
+                .verifySso(ssoVerificationRequest)
+                .then((result) => {
+                this.logger.verbose("1gd1iv", correlationId);
+                // TBD to add profileTelemetry later in localStorage with 24h TTL
+                try {
+                    const cacheEntry = JSON.stringify({
+                        ssoCapable: result,
+                        expiresOn: Date.now() + SSO_CAPABLE_TTL_MS,
+                    });
+                    window.localStorage.setItem(ssoCacheKey, cacheEntry);
+                }
+                catch {
+                    this.logger.warning("18lmoj", correlationId);
+                }
+                ssoCapableMeasurement.end({
+                    fromCache: false,
+                    success: result,
+                }, undefined);
+            })
+                .catch((error) => {
+                this.logger.warning("05g83w", correlationId);
+                // reset the cache
+                try {
+                    window.localStorage.removeItem(ssoCacheKey);
+                }
+                catch {
+                    this.logger.warning("0nlf9q", correlationId);
+                }
+                ssoCapableMeasurement.end({
+                    fromCache: false,
+                    success: false,
+                }, error);
+            });
+        }, 0);
     }
     // #endregion
     // #region Silent Flow
@@ -552,21 +636,22 @@ class StandardController {
         const correlationId = this.getRequestCorrelationId(request);
         const validRequest = {
             ...request,
-            // will be PromptValue.NONE or PromptValue.NO_SESSION
-            prompt: request.prompt,
             correlationId: correlationId,
         };
-        this.ssoSilentMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.SsoSilent, correlationId);
+        this.ssoSilentMeasurement = this.performanceClient.startMeasurement(SsoSilent, correlationId);
         this.ssoSilentMeasurement?.add({
             scenarioId: request.scenarioId,
+            ssoCapable: this.getCachedSsoCapable(),
         });
-        preflightCheck(this.initialized, this.ssoSilentMeasurement, request.account);
+        preflightCheck(this.initialized, this.ssoSilentMeasurement, this.config, validRequest);
         this.ssoSilentMeasurement?.increment({
             visibilityChangeCount: 0,
+            onlineStatusChangeCount: 0,
         });
-        document.addEventListener("visibilitychange", this.trackPageVisibilityWithMeasurement);
-        this.logger.verbose("ssoSilent called", correlationId);
-        this.eventHandler.emitEvent(EventType.SSO_SILENT_START, InteractionType.Silent, validRequest);
+        this.addStateChangeListeners(this.trackStateChangeWithMeasurement);
+        const loggedInAccounts = this.getAllAccounts();
+        this.logger.verbose("0w1b45", correlationId);
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, correlationId, InteractionType.Silent, validRequest);
         let result;
         if (this.canUsePlatformBroker(validRequest)) {
             this.ssoSilentMeasurement?.add({
@@ -579,7 +664,7 @@ class StandardController {
                 });
                 // If native token acquisition fails for availability reasons fallback to standard flow
                 if (e instanceof NativeAuthError && isFatalNativeAuthError(e)) {
-                    this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
+                    this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt platform broker calls
                     const silentIframeClient = this.createSilentIframeClient(validRequest.correlationId);
                     return silentIframeClient.acquireToken(validRequest);
                 }
@@ -592,23 +677,28 @@ class StandardController {
         }
         return result
             .then((response) => {
-            this.eventHandler.emitEvent(EventType.SSO_SILENT_SUCCESS, InteractionType.Silent, response);
+            const isLoggingIn = loggedInAccounts.length < this.getAllAccounts().length;
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, correlationId, InteractionType.Silent, response);
+            if (isLoggingIn) {
+                this.eventHandler.emitEvent(EventType.LOGIN_SUCCESS, correlationId, InteractionType.Silent, response.account);
+            }
             this.ssoSilentMeasurement?.end({
                 success: true,
+                isNativeBroker: response.fromPlatformBroker,
                 accessTokenSize: response.accessToken.length,
                 idTokenSize: response.idToken.length,
             }, undefined, response.account);
             return response;
         })
             .catch((e) => {
-            this.eventHandler.emitEvent(EventType.SSO_SILENT_FAILURE, InteractionType.Silent, null, e);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, correlationId, InteractionType.Silent, null, e);
             this.ssoSilentMeasurement?.end({
                 success: false,
             }, e, request.account);
             throw e;
         })
             .finally(() => {
-            document.removeEventListener("visibilitychange", this.trackPageVisibilityWithMeasurement);
+            this.removeStateChangeListeners(this.trackStateChangeWithMeasurement);
         });
     }
     /**
@@ -623,10 +713,10 @@ class StandardController {
      */
     async acquireTokenByCode(request) {
         const correlationId = this.getRequestCorrelationId(request);
-        this.logger.trace("acquireTokenByCode called", correlationId);
-        const atbcMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenByCode, correlationId);
-        preflightCheck(this.initialized, atbcMeasurement);
-        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_START, InteractionType.Silent, request);
+        this.logger.trace("0ch6ga", correlationId);
+        const atbcMeasurement = this.performanceClient.startMeasurement(AcquireTokenByCode, correlationId);
+        preflightCheck(this.initialized, atbcMeasurement, this.config, request);
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, correlationId, InteractionType.Silent, request);
         atbcMeasurement.add({ scenarioId: request.scenarioId });
         try {
             if (request.code && request.nativeAccountId) {
@@ -637,13 +727,13 @@ class StandardController {
                 const hybridAuthCode = request.code;
                 let response = this.hybridAuthCodeResponses.get(hybridAuthCode);
                 if (!response) {
-                    this.logger.verbose("Initiating new acquireTokenByCode request", correlationId);
+                    this.logger.verbose("06eh73", correlationId);
                     response = this.acquireTokenByCodeAsync({
                         ...request,
                         correlationId,
                     })
                         .then((result) => {
-                        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_SUCCESS, InteractionType.Silent, result);
+                        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, correlationId, InteractionType.Silent, result);
                         this.hybridAuthCodeResponses.delete(hybridAuthCode);
                         atbcMeasurement.end({
                             success: true,
@@ -654,7 +744,7 @@ class StandardController {
                     })
                         .catch((error) => {
                         this.hybridAuthCodeResponses.delete(hybridAuthCode);
-                        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE, InteractionType.Silent, null, error);
+                        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, correlationId, InteractionType.Silent, null, error);
                         atbcMeasurement.end({
                             success: false,
                         }, error);
@@ -663,7 +753,7 @@ class StandardController {
                     this.hybridAuthCodeResponses.set(hybridAuthCode, response);
                 }
                 else {
-                    this.logger.verbose("Existing acquireTokenByCode request found", correlationId);
+                    this.logger.verbose("0qgp28", correlationId);
                     atbcMeasurement.discard();
                 }
                 return await response;
@@ -677,15 +767,15 @@ class StandardController {
                         ...request,
                         correlationId,
                     }, ApiId.acquireTokenByCode, request.nativeAccountId).catch((e) => {
+                        atbcMeasurement.add({
+                            brokerErrorName: e.name,
+                            brokerErrorCode: e.errorCode,
+                        });
                         // If native token acquisition fails for availability reasons fallback to standard flow
                         if (e instanceof NativeAuthError &&
                             isFatalNativeAuthError(e)) {
                             this.platformAuthProvider = undefined; // If extension gets uninstalled during session prevent future requests from continuing to attempt
                         }
-                        atbcMeasurement.add({
-                            brokerErrorName: e.name,
-                            brokerErrorCode: e.errorCode,
-                        });
                         throw e;
                     });
                     atbcMeasurement.end({
@@ -702,7 +792,7 @@ class StandardController {
             }
         }
         catch (e) {
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_BY_CODE_FAILURE, InteractionType.Silent, null, e);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, correlationId, InteractionType.Silent, null, e);
             atbcMeasurement.end({
                 success: false,
             }, e);
@@ -715,14 +805,16 @@ class StandardController {
      * @returns Result of the operation to redeem the authorization code
      */
     async acquireTokenByCodeAsync(request) {
-        this.logger.trace("acquireTokenByCodeAsync called", request.correlationId);
+        const correlationId = this.getRequestCorrelationId(request);
+        this.logger.trace("10d9hy", correlationId);
         this.acquireTokenByCodeAsyncMeasurement =
-            this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenByCodeAsync, request.correlationId);
+            this.performanceClient.startMeasurement(AcquireTokenByCodeAsync, correlationId);
         this.acquireTokenByCodeAsyncMeasurement?.increment({
             visibilityChangeCount: 0,
+            onlineStatusChangeCount: 0,
         });
-        document.addEventListener("visibilitychange", this.trackPageVisibilityWithMeasurement);
-        const silentAuthCodeClient = this.createSilentAuthCodeClient(request.correlationId);
+        this.addStateChangeListeners(this.trackStateChangeWithMeasurement);
+        const silentAuthCodeClient = this.createSilentAuthCodeClient(correlationId);
         const silentTokenResult = await silentAuthCodeClient
             .acquireToken(request)
             .then((response) => {
@@ -739,7 +831,7 @@ class StandardController {
             throw tokenRenewalError;
         })
             .finally(() => {
-            document.removeEventListener("visibilitychange", this.trackPageVisibilityWithMeasurement);
+            this.removeStateChangeListeners(this.trackStateChangeWithMeasurement);
         });
         return silentTokenResult;
     }
@@ -751,13 +843,12 @@ class StandardController {
      * @returns A promise that, when resolved, returns the access token
      */
     async acquireTokenFromCache(commonRequest, cacheLookupPolicy) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.AcquireTokenFromCache, commonRequest.correlationId);
         switch (cacheLookupPolicy) {
             case CacheLookupPolicy.Default:
             case CacheLookupPolicy.AccessToken:
             case CacheLookupPolicy.AccessTokenAndRefreshToken:
                 const silentCacheClient = this.createSilentCacheClient(commonRequest.correlationId);
-                return invokeAsync(silentCacheClient.acquireToken.bind(silentCacheClient), PerformanceEvents.SilentCacheClientAcquireToken, this.logger, this.performanceClient, commonRequest.correlationId)(commonRequest);
+                return invokeAsync(silentCacheClient.acquireToken.bind(silentCacheClient), SilentCacheClientAcquireToken, this.logger, this.performanceClient, commonRequest.correlationId)(commonRequest);
             default:
                 throw createClientAuthError(ClientAuthErrorCodes.tokenRefreshRequired);
         }
@@ -769,14 +860,13 @@ class StandardController {
      * @returns A promise that, when resolved, returns the access token
      */
     async acquireTokenByRefreshToken(commonRequest, cacheLookupPolicy) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.AcquireTokenByRefreshToken, commonRequest.correlationId);
         switch (cacheLookupPolicy) {
             case CacheLookupPolicy.Default:
             case CacheLookupPolicy.AccessTokenAndRefreshToken:
             case CacheLookupPolicy.RefreshToken:
             case CacheLookupPolicy.RefreshTokenAndNetwork:
                 const silentRefreshClient = this.createSilentRefreshClient(commonRequest.correlationId);
-                return invokeAsync(silentRefreshClient.acquireToken.bind(silentRefreshClient), PerformanceEvents.SilentRefreshClientAcquireToken, this.logger, this.performanceClient, commonRequest.correlationId)(commonRequest);
+                return invokeAsync(silentRefreshClient.acquireToken.bind(silentRefreshClient), SilentRefreshClientAcquireToken, this.logger, this.performanceClient, commonRequest.correlationId)(commonRequest);
             default:
                 throw createClientAuthError(ClientAuthErrorCodes.tokenRefreshRequired);
         }
@@ -787,25 +877,11 @@ class StandardController {
      * @returns A promise that, when resolved, returns the access token
      */
     async acquireTokenBySilentIframe(request) {
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.AcquireTokenBySilentIframe, request.correlationId);
         const silentIframeClient = this.createSilentIframeClient(request.correlationId);
-        return invokeAsync(silentIframeClient.acquireToken.bind(silentIframeClient), PerformanceEvents.SilentIframeClientAcquireToken, this.logger, this.performanceClient, request.correlationId)(request);
+        return invokeAsync(silentIframeClient.acquireToken.bind(silentIframeClient), SilentIframeClientAcquireToken, this.logger, this.performanceClient, request.correlationId)(request);
     }
     // #endregion
     // #region Logout
-    /**
-     * Deprecated logout function. Use logoutRedirect or logoutPopup instead
-     * @param logoutRequest
-     * @deprecated
-     */
-    async logout(logoutRequest) {
-        const correlationId = this.getRequestCorrelationId(logoutRequest);
-        this.logger.warning("logout API is deprecated and will be removed in msal-browser v3.0.0. Use logoutRedirect instead.", correlationId);
-        return this.logoutRedirect({
-            correlationId,
-            ...logoutRequest,
-        });
-    }
     /**
      * Use to log out the current user, and redirect the user to the postLogoutRedirectUri.
      * Default behaviour is to redirect the user to `window.location.href`.
@@ -843,7 +919,6 @@ class StandardController {
      */
     async clearCache(logoutRequest) {
         if (!this.isBrowserEnvironment) {
-            this.logger.info("in non-browser environment, returning early.");
             return;
         }
         const correlationId = this.getRequestCorrelationId(logoutRequest);
@@ -858,8 +933,7 @@ class StandardController {
      * @returns Array of AccountInfo objects in cache
      */
     getAllAccounts(accountFilter) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAllAccounts(this.logger, this.browserStorage, this.isBrowserEnvironment, correlationId, accountFilter);
+        return getAllAccounts(this.logger, this.browserStorage, this.isBrowserEnvironment, this.getRequestCorrelationId(), accountFilter);
     }
     /**
      * Returns the first account found in the cache that matches the account filter passed in.
@@ -867,57 +941,20 @@ class StandardController {
      * @returns The first account found in the cache matching the provided filter or null if no account could be found.
      */
     getAccount(accountFilter) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAccount(accountFilter, this.logger, this.browserStorage, correlationId);
-    }
-    /**
-     * Returns the signed in account matching username.
-     * (the account object is created at the time of successful login)
-     * or null when no matching account is found.
-     * This API is provided for convenience but getAccountById should be used for best reliability
-     * @param username
-     * @returns The account object stored in MSAL
-     */
-    getAccountByUsername(username) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAccountByUsername(username, this.logger, this.browserStorage, correlationId);
-    }
-    /**
-     * Returns the signed in account matching homeAccountId.
-     * (the account object is created at the time of successful login)
-     * or null when no matching account is found
-     * @param homeAccountId
-     * @returns The account object stored in MSAL
-     */
-    getAccountByHomeId(homeAccountId) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAccountByHomeId(homeAccountId, this.logger, this.browserStorage, correlationId);
-    }
-    /**
-     * Returns the signed in account matching localAccountId.
-     * (the account object is created at the time of successful login)
-     * or null when no matching account is found
-     * @param localAccountId
-     * @returns The account object stored in MSAL
-     */
-    getAccountByLocalId(localAccountId) {
-        const correlationId = this.getRequestCorrelationId();
-        return getAccountByLocalId(localAccountId, this.logger, this.browserStorage, correlationId);
+        return getAccount(accountFilter, this.logger, this.browserStorage, this.getRequestCorrelationId());
     }
     /**
      * Sets the account to use as the active account. If no account is passed to the acquireToken APIs, then MSAL will use this active account.
      * @param account
      */
     setActiveAccount(account) {
-        const correlationId = this.getRequestCorrelationId();
-        setActiveAccount(account, this.browserStorage, correlationId);
+        setActiveAccount(account, this.browserStorage, this.getRequestCorrelationId());
     }
     /**
      * Gets the currently active account
      */
     getActiveAccount() {
-        const correlationId = this.getRequestCorrelationId();
-        return getActiveAccount(this.browserStorage, correlationId);
+        return getActiveAccount(this.browserStorage, this.getRequestCorrelationId());
     }
     // #endregion
     /**
@@ -927,14 +964,30 @@ class StandardController {
      * @returns
      */
     async hydrateCache(result, request) {
-        this.logger.verbose("hydrateCache called");
+        this.logger.verbose("16jycr", result.correlationId);
         // Account gets saved to browser storage regardless of native or not
-        const accountEntity = AccountEntity.createFromAccountInfo(result.account, result.cloudGraphHostName, result.msGraphHost);
+        const accountEntity = AccountEntityUtils.createAccountEntityFromAccountInfo(result.account, result.cloudGraphHostName, result.msGraphHost);
         await this.browserStorage.setAccount(accountEntity, result.correlationId, AuthToken.isKmsi(result.idTokenClaims), ApiId.hydrateCache);
-        if (result.fromNativeBroker) {
-            this.logger.verbose("Response was from native broker, storing in-memory");
-            // Tokens from native broker are stored in-memory
-            return this.nativeInternalStorage.hydrateCache(result, request);
+        if (result.fromPlatformBroker) {
+            this.logger.verbose("1i5atf", result.correlationId);
+            // Create idToken entity and store in browser storage
+            const idTokenEntity = CacheHelpers.createIdTokenEntity(result.account.homeAccountId, result.account.environment, result.idToken, this.config.auth.clientId, result.tenantId);
+            // Create accessToken entity and store in native internal storage
+            const accessTokenEntity = CacheHelpers.createAccessTokenEntity(result.account.homeAccountId, result.account.environment, result.accessToken, this.config.auth.clientId, result.tenantId, result.scopes.join(" "), result.expiresOn
+                ? TimeUtils.toSecondsFromDate(result.expiresOn)
+                : 0, result.extExpiresOn
+                ? TimeUtils.toSecondsFromDate(result.extExpiresOn)
+                : 0, base64Decode, undefined, // refreshOn
+            result.tokenType, undefined, // userAssertionHash
+            request.sshKid);
+            if (request.resource) {
+                accessTokenEntity.resource = request.resource;
+            }
+            const kmsi = AuthToken.isKmsi(result.idTokenClaims);
+            // Store idToken in browser storage
+            await this.browserStorage.setIdTokenCredential(idTokenEntity, result.correlationId, kmsi);
+            // Store accessToken in native internal storage
+            await this.nativeInternalStorage.setAccessTokenCredential(accessTokenEntity, result.correlationId, kmsi);
         }
         else {
             return this.browserStorage.hydrateCache(result, request);
@@ -946,42 +999,43 @@ class StandardController {
      * @param request
      */
     async acquireTokenNative(request, apiId, accountId, cacheLookupPolicy) {
-        this.logger.trace("acquireTokenNative called");
+        const correlationId = this.getRequestCorrelationId(request);
+        this.logger.trace("0b9y3p", correlationId);
         if (!this.platformAuthProvider) {
             throw createBrowserAuthError(nativeConnectionNotEstablished);
         }
-        const nativeClient = new PlatformAuthInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, apiId, this.performanceClient, this.platformAuthProvider, accountId || this.getNativeAccountId(request), this.nativeInternalStorage, request.correlationId);
-        return nativeClient.acquireToken(request, cacheLookupPolicy);
+        const nativeClient = new PlatformAuthInteractionClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, apiId, this.performanceClient, this.platformAuthProvider, accountId || this.getNativeAccountId(request), this.nativeInternalStorage, correlationId);
+        return invokeAsync(nativeClient.acquireToken.bind(nativeClient), NativeInteractionClientAcquireToken, this.logger, this.performanceClient, correlationId)(request, cacheLookupPolicy);
     }
     /**
      * Returns boolean indicating if this request can use the platform broker
      * @param request
      */
     canUsePlatformBroker(request, accountId) {
-        this.logger.trace("canUsePlatformBroker called");
+        const correlationId = this.getRequestCorrelationId(request);
+        this.logger.trace("1n9lbl", correlationId);
         if (!this.platformAuthProvider) {
-            this.logger.trace("canUsePlatformBroker: platform broker unavilable, returning false");
+            this.logger.trace("0vnu11", correlationId);
             return false;
         }
-        if (!isPlatformAuthAllowed(this.config, this.logger, this.platformAuthProvider, request.authenticationScheme)) {
-            this.logger.trace("canUsePlatformBroker: isBrokerAvailable returned false, returning false");
+        if (!isPlatformAuthAllowed(this.config, this.logger, correlationId, this.platformAuthProvider, request.authenticationScheme)) {
+            this.logger.trace("0yoy1g", correlationId);
             return false;
         }
         if (request.prompt) {
             switch (request.prompt) {
-                case PromptValue.NONE:
-                case PromptValue.CONSENT:
-                case PromptValue.LOGIN:
-                case PromptValue.SELECT_ACCOUNT:
-                    this.logger.trace("canUsePlatformBroker: prompt is compatible with platform broker flow");
+                case Constants.PromptValue.NONE:
+                case Constants.PromptValue.CONSENT:
+                case Constants.PromptValue.LOGIN:
+                    this.logger.trace("0vdv8e", correlationId);
                     break;
                 default:
-                    this.logger.trace(`canUsePlatformBroker: prompt = ${request.prompt} is not compatible with platform broker flow, returning false`);
+                    this.logger.trace("0pdzw6", correlationId);
                     return false;
             }
         }
         if (!accountId && !this.getNativeAccountId(request)) {
-            this.logger.trace("canUsePlatformBroker: nativeAccountId is not available, returning false");
+            this.logger.trace("16lbtk", correlationId);
             return false;
         }
         return true;
@@ -997,7 +1051,9 @@ class StandardController {
                 loginHint: request.loginHint,
                 sid: request.sid,
             }) ||
-            this.getActiveAccount();
+            (!request.loginHint && !request.sid
+                ? this.getActiveAccount()
+                : null);
         return (account && account.nativeAccountId) || "";
     }
     /**
@@ -1005,39 +1061,39 @@ class StandardController {
      * @param correlationId
      */
     createPopupClient(correlationId) {
-        return new PopupClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeInternalStorage, this.platformAuthProvider, correlationId);
+        return new PopupClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeInternalStorage, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Redirect Interaction Client
      * @param correlationId
      */
     createRedirectClient(correlationId) {
-        return new RedirectClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeInternalStorage, this.platformAuthProvider, correlationId);
+        return new RedirectClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.nativeInternalStorage, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Silent Iframe Interaction Client
      * @param correlationId
      */
     createSilentIframeClient(correlationId) {
-        return new SilentIframeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.ssoSilent, this.performanceClient, this.nativeInternalStorage, this.platformAuthProvider, correlationId);
+        return new SilentIframeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.ssoSilent, this.performanceClient, this.nativeInternalStorage, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Silent Cache Interaction Client
      */
     createSilentCacheClient(correlationId) {
-        return new SilentCacheClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.platformAuthProvider, correlationId);
+        return new SilentCacheClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Silent Refresh Interaction Client
      */
     createSilentRefreshClient(correlationId) {
-        return new SilentRefreshClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, this.platformAuthProvider, correlationId);
+        return new SilentRefreshClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, this.performanceClient, correlationId, this.platformAuthProvider);
     }
     /**
      * Returns new instance of the Silent AuthCode Interaction Client
      */
     createSilentAuthCodeClient(correlationId) {
-        return new SilentAuthCodeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.acquireTokenByCode, this.performanceClient, this.platformAuthProvider, correlationId);
+        return new SilentAuthCodeClient(this.config, this.browserStorage, this.browserCrypto, this.logger, this.eventHandler, this.navigationClient, ApiId.acquireTokenByCode, this.performanceClient, correlationId, this.platformAuthProvider);
     }
     /**
      * Adds event callbacks to array
@@ -1072,36 +1128,6 @@ class StandardController {
     removePerformanceCallback(callbackId) {
         return this.performanceClient.removePerformanceCallback(callbackId);
     }
-    /**
-     * Adds event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
-     * @deprecated These events will be raised by default and this method will be removed in a future major version.
-     */
-    enableAccountStorageEvents() {
-        if (this.config.cache.cacheLocation !==
-            BrowserCacheLocation.LocalStorage) {
-            this.logger.info("Account storage events are only available when cacheLocation is set to localStorage");
-            return;
-        }
-        this.eventHandler.subscribeCrossTab();
-    }
-    /**
-     * Removes event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
-     * @deprecated These events will be raised by default and this method will be removed in a future major version.
-     */
-    disableAccountStorageEvents() {
-        if (this.config.cache.cacheLocation !==
-            BrowserCacheLocation.LocalStorage) {
-            this.logger.info("Account storage events are only available when cacheLocation is set to localStorage");
-            return;
-        }
-        this.eventHandler.unsubscribeCrossTab();
-    }
-    /**
-     * Gets the token cache for the application.
-     */
-    getTokenCache() {
-        return this.tokenCache;
-    }
     /**
      * Returns the logger instance
      */
@@ -1167,7 +1193,7 @@ class StandardController {
          * Included for fallback for non-browser environments,
          * and to ensure this method always returns a string.
          */
-        return Constants.EMPTY_STRING;
+        return "";
     }
     // #endregion
     /**
@@ -1181,7 +1207,7 @@ class StandardController {
      */
     async loginRedirect(request) {
         const correlationId = this.getRequestCorrelationId(request);
-        this.logger.verbose("loginRedirect called", correlationId);
+        this.logger.verbose("0lz9hf", correlationId);
         return this.acquireTokenRedirect({
             correlationId,
             ...(request || DEFAULT_REQUEST),
@@ -1196,7 +1222,7 @@ class StandardController {
      */
     loginPopup(request) {
         const correlationId = this.getRequestCorrelationId(request);
-        this.logger.verbose("loginPopup called", correlationId);
+        this.logger.verbose("0qw7v5", correlationId);
         return this.acquireTokenPopup({
             correlationId,
             ...(request || DEFAULT_REQUEST),
@@ -1210,13 +1236,14 @@ class StandardController {
      */
     async acquireTokenSilent(request) {
         const correlationId = this.getRequestCorrelationId(request);
-        const atsMeasurement = this.performanceClient.startMeasurement(PerformanceEvents.AcquireTokenSilent, correlationId);
+        const atsMeasurement = this.performanceClient.startMeasurement(AcquireTokenSilent, correlationId);
         atsMeasurement.add({
             cacheLookupPolicy: request.cacheLookupPolicy,
             scenarioId: request.scenarioId,
+            ssoCapable: this.getCachedSsoCapable(),
         });
-        preflightCheck(this.initialized, atsMeasurement, request.account);
-        this.logger.verbose("acquireTokenSilent called", correlationId);
+        preflightCheck(this.initialized, atsMeasurement, this.config, request);
+        this.logger.verbose("0x1c4s", correlationId);
         const account = request.account || this.getActiveAccount();
         if (!account) {
             throw createBrowserAuthError(noAccountError);
@@ -1262,9 +1289,9 @@ class StandardController {
         const silentRequestKey = JSON.stringify(thumbprint);
         const inProgressRequest = this.activeSilentTokenRequests.get(silentRequestKey);
         if (typeof inProgressRequest === "undefined") {
-            this.logger.verbose("acquireTokenSilent called for the first time, storing active request", correlationId);
+            this.logger.verbose("0fcjbk", correlationId);
             this.performanceClient.addFields({ deduped: false }, correlationId);
-            const activeRequest = invokeAsync(this.acquireTokenSilentAsync.bind(this), PerformanceEvents.AcquireTokenSilentAsync, this.logger, this.performanceClient, correlationId)({
+            const activeRequest = invokeAsync(this.acquireTokenSilentAsync.bind(this), AcquireTokenSilentAsync, this.logger, this.performanceClient, correlationId)({
                 ...request,
                 correlationId,
             }, account);
@@ -1274,7 +1301,7 @@ class StandardController {
             });
         }
         else {
-            this.logger.verbose("acquireTokenSilent has been called previously, returning the result from the first call", correlationId);
+            this.logger.verbose("1yq7nb", correlationId);
             this.performanceClient.addFields({ deduped: true }, correlationId);
             return inProgressRequest;
         }
@@ -1286,18 +1313,21 @@ class StandardController {
      * @returns {Promise.<AuthenticationResult>} - a promise that is fulfilled when this function has completed, or rejected if an error was raised. Returns the {@link AuthResponse}
      */
     async acquireTokenSilentAsync(request, account) {
-        const trackPageVisibility = () => this.trackPageVisibility(request.correlationId);
-        this.performanceClient.addQueueMeasurement(PerformanceEvents.AcquireTokenSilentAsync, request.correlationId);
-        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, InteractionType.Silent, request);
+        const trackStateChange = (event) => this.trackStateChange(request.correlationId, event);
+        this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_START, request.correlationId, InteractionType.Silent, request);
         if (request.correlationId) {
-            this.performanceClient.incrementFields({ visibilityChangeCount: 0 }, request.correlationId);
+            this.performanceClient.incrementFields({ visibilityChangeCount: 0, onlineStatusChangeCount: 0 }, request.correlationId);
         }
-        document.addEventListener("visibilitychange", trackPageVisibility);
-        const silentRequest = await invokeAsync(initializeSilentRequest, PerformanceEvents.InitializeSilentRequest, this.logger, this.performanceClient, request.correlationId)(request, account, this.config, this.performanceClient, this.logger);
+        this.addStateChangeListeners(trackStateChange);
+        const silentRequest = await invokeAsync(initializeSilentRequest, InitializeSilentRequest, this.logger, this.performanceClient, request.correlationId)(request, account, this.config, this.performanceClient, this.logger);
         const cacheLookupPolicy = request.cacheLookupPolicy || CacheLookupPolicy.Default;
         const result = this.acquireTokenSilentNoIframe(silentRequest, cacheLookupPolicy).catch(async (refreshTokenError) => {
             const shouldTryToResolveSilently = checkIfRefreshTokenErrorCanBeResolvedSilently(refreshTokenError, cacheLookupPolicy);
             if (shouldTryToResolveSilently) {
+                const silentRefreshReason = `${refreshTokenError.errorCode}${refreshTokenError.subError
+                    ? `|${refreshTokenError.subError}`
+                    : ""}`;
+                this.performanceClient.addFields({ silentRefreshReason }, request.correlationId);
                 if (!this.activeIframeRequest) {
                     let _resolve;
                     // Always set the active request tracker immediately after checking it to prevent races
@@ -1307,8 +1337,8 @@ class StandardController {
                         }),
                         silentRequest.correlationId,
                     ];
-                    this.logger.verbose("Refresh token expired/invalid or CacheLookupPolicy is set to Skip, attempting acquire token by iframe.", silentRequest.correlationId);
-                    return invokeAsync(this.acquireTokenBySilentIframe.bind(this), PerformanceEvents.AcquireTokenBySilentIframe, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest)
+                    this.logger.verbose("0rh08z", silentRequest.correlationId);
+                    return invokeAsync(this.acquireTokenBySilentIframe.bind(this), AcquireTokenBySilentIframe, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest)
                         .then((iframeResult) => {
                         _resolve(true);
                         return iframeResult;
@@ -1323,8 +1353,8 @@ class StandardController {
                 }
                 else if (cacheLookupPolicy !== CacheLookupPolicy.Skip) {
                     const [activePromise, activeCorrelationId] = this.activeIframeRequest;
-                    this.logger.verbose(`Iframe request is already in progress, awaiting resolution for request with correlationId: ${activeCorrelationId}`, silentRequest.correlationId);
-                    const awaitConcurrentIframeMeasure = this.performanceClient.startMeasurement(PerformanceEvents.AwaitConcurrentIframe, silentRequest.correlationId);
+                    this.logger.verbose("1w8fso", silentRequest.correlationId);
+                    const awaitConcurrentIframeMeasure = this.performanceClient.startMeasurement(AwaitConcurrentIframe, silentRequest.correlationId);
                     awaitConcurrentIframeMeasure.add({
                         awaitIframeCorrelationId: activeCorrelationId,
                     });
@@ -1333,20 +1363,20 @@ class StandardController {
                         success: activePromiseResult,
                     });
                     if (activePromiseResult) {
-                        this.logger.verbose(`Parallel iframe request with correlationId: ${activeCorrelationId} succeeded. Retrying cache and/or RT redemption`, silentRequest.correlationId);
+                        this.logger.verbose("0ywzzi", silentRequest.correlationId);
                         // Retry cache lookup and/or RT exchange after iframe completes
                         return this.acquireTokenSilentNoIframe(silentRequest, cacheLookupPolicy);
                     }
                     else {
-                        this.logger.info(`Iframe request with correlationId: ${activeCorrelationId} failed. Interaction is required.`);
+                        this.logger.info("17y14q", silentRequest.correlationId);
                         // If previous iframe request failed, it's unlikely to succeed this time. Throw original error.
                         throw refreshTokenError;
                     }
                 }
                 else {
                     // Cache policy set to skip and another iframe request is already in progress
-                    this.logger.warning("Another iframe request is currently in progress and CacheLookupPolicy is set to Skip. This may result in degraded performance and/or reliability for both calls. Please consider changing the CacheLookupPolicy to take advantage of request queuing and token cache.", silentRequest.correlationId);
-                    return invokeAsync(this.acquireTokenBySilentIframe.bind(this), PerformanceEvents.AcquireTokenBySilentIframe, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest);
+                    this.logger.warning("1bd4p8", silentRequest.correlationId);
+                    return invokeAsync(this.acquireTokenBySilentIframe.bind(this), AcquireTokenBySilentIframe, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest);
                 }
             }
             else {
@@ -1356,18 +1386,21 @@ class StandardController {
         });
         return result
             .then((response) => {
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, InteractionType.Silent, response);
-            this.performanceClient.addFields({
-                fromCache: response.fromCache,
-            }, request.correlationId);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_SUCCESS, request.correlationId, InteractionType.Silent, response);
+            if (request.correlationId) {
+                this.performanceClient.addFields({
+                    fromCache: response.fromCache,
+                    isNativeBroker: response.fromPlatformBroker,
+                }, request.correlationId);
+            }
             return response;
         })
             .catch((tokenRenewalError) => {
-            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, InteractionType.Silent, null, tokenRenewalError);
+            this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_FAILURE, request.correlationId, InteractionType.Silent, null, tokenRenewalError);
             throw tokenRenewalError;
         })
             .finally(() => {
-            document.removeEventListener("visibilitychange", trackPageVisibility);
+            this.removeStateChangeListeners(trackStateChange);
         });
     }
     /**
@@ -1378,9 +1411,9 @@ class StandardController {
      */
     async acquireTokenSilentNoIframe(silentRequest, cacheLookupPolicy) {
         // if the cache policy is set to access_token only, we should not be hitting the native layer yet
-        if (isPlatformAuthAllowed(this.config, this.logger, this.platformAuthProvider, silentRequest.authenticationScheme) &&
+        if (isPlatformAuthAllowed(this.config, this.logger, silentRequest.correlationId, this.platformAuthProvider, silentRequest.authenticationScheme) &&
             silentRequest.account.nativeAccountId) {
-            this.logger.verbose("acquireTokenSilent - attempting to acquire token from native platform");
+            this.logger.verbose("0sczo4", silentRequest.correlationId);
             this.performanceClient.addFields({ isPlatformBrokerRequest: true }, silentRequest.correlationId);
             return this.acquireTokenNative(silentRequest, ApiId.acquireTokenSilent_silentFlow, silentRequest.account.nativeAccountId, cacheLookupPolicy).catch(async (e) => {
                 this.performanceClient.addFields({
@@ -1389,7 +1422,7 @@ class StandardController {
                 }, silentRequest.correlationId);
                 // If native token acquisition fails for availability reasons fallback to web flow
                 if (e instanceof NativeAuthError && isFatalNativeAuthError(e)) {
-                    this.logger.verbose("acquireTokenSilent - native platform unavailable, falling back to web flow");
+                    this.logger.verbose("07rkmb", silentRequest.correlationId);
                     this.platformAuthProvider = undefined; // Prevent future requests from continuing to attempt
                     // Cache will not contain tokens, given that previous WAM requests succeeded. Skip cache and RT renewal and go straight to iframe renewal
                     throw createClientAuthError(ClientAuthErrorCodes.tokenRefreshRequired);
@@ -1398,17 +1431,17 @@ class StandardController {
             });
         }
         else {
-            this.logger.verbose("acquireTokenSilent - attempting to acquire token from web flow");
+            this.logger.verbose("0ox81t", silentRequest.correlationId);
             // add logs to identify embedded cache retrieval
             if (cacheLookupPolicy === CacheLookupPolicy.AccessToken) {
-                this.logger.verbose("acquireTokenSilent - cache lookup policy set to AccessToken, attempting to acquire token from local cache");
+                this.logger.verbose("0fvwxe", silentRequest.correlationId);
             }
-            return invokeAsync(this.acquireTokenFromCache.bind(this), PerformanceEvents.AcquireTokenFromCache, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest, cacheLookupPolicy).catch((cacheError) => {
+            return invokeAsync(this.acquireTokenFromCache.bind(this), AcquireTokenFromCache, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest, cacheLookupPolicy).catch((cacheError) => {
                 if (cacheLookupPolicy === CacheLookupPolicy.AccessToken) {
                     throw cacheError;
                 }
-                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_NETWORK_START, InteractionType.Silent, silentRequest);
-                return invokeAsync(this.acquireTokenByRefreshToken.bind(this), PerformanceEvents.AcquireTokenByRefreshToken, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest, cacheLookupPolicy);
+                this.eventHandler.emitEvent(EventType.ACQUIRE_TOKEN_NETWORK_START, silentRequest.correlationId, InteractionType.Silent, silentRequest);
+                return invokeAsync(this.acquireTokenByRefreshToken.bind(this), AcquireTokenByRefreshToken, this.logger, this.performanceClient, silentRequest.correlationId)(silentRequest, cacheLookupPolicy);
             });
         }
     }
@@ -1417,8 +1450,8 @@ class StandardController {
      * @param correlationId
      */
     async preGeneratePkceCodes(correlationId) {
-        this.logger.verbose("Generating new PKCE codes");
-        this.pkceCode = await invokeAsync(generatePkceCodes, PerformanceEvents.GeneratePkceCodes, this.logger, this.performanceClient, correlationId)(this.performanceClient, this.logger, correlationId);
+        this.logger.verbose("1x6uj6", correlationId);
+        this.pkceCode = await invokeAsync(generatePkceCodes, GeneratePkceCodes, this.logger, this.performanceClient, correlationId)(this.performanceClient, this.logger, correlationId);
         return Promise.resolve();
     }
     /**
@@ -1426,14 +1459,18 @@ class StandardController {
      * @param correlationId
      */
     getPreGeneratedPkceCodes(correlationId) {
-        this.logger.verbose("Attempting to pick up pre-generated PKCE codes");
         const res = this.pkceCode ? { ...this.pkceCode } : undefined;
         this.pkceCode = undefined;
-        this.logger.verbose(`${res ? "Found" : "Did not find"} pre-generated PKCE codes`);
+        if (res) {
+            this.logger.verbose("12js1o", correlationId);
+        }
+        else {
+            this.logger.verbose("1oe9ci", correlationId);
+        }
         this.performanceClient.addFields({ usePreGeneratedPkce: !!res }, correlationId);
         return res;
     }
-    logMultipleInstances(performanceEvent) {
+    logMultipleInstances(performanceEvent, correlationId) {
         const clientId = this.config.auth.clientId;
         if (!window)
             return;
@@ -1444,11 +1481,11 @@ class StandardController {
         // @ts-ignore
         const clientIds = window.msal.clientIds;
         if (clientIds.length > 0) {
-            this.logger.verbose("There is already an instance of MSAL.js in the window.");
+            this.logger.verbose("1qtz3l", correlationId);
         }
         // @ts-ignore
         window.msal.clientIds.push(clientId);
-        collectInstanceStats(clientId, performanceEvent, this.logger);
+        collectInstanceStats(clientId, performanceEvent, this.logger, correlationId);
     }
 }
 /**