fix auto-pause issue

Author: surya3655

src/Components/Endpoints/src/Rendering/EndpointHtmlRenderer.Streaming.cs

@@ -104,8 +104,6 @@ internal void EmitInitializersIfNecessary(HttpContext httpContext, TextWriter wr
             writer.Write("<!--Blazor-Web-Initializers:");
             writer.Write(initializersBase64);
             writer.Write("-->");
-
-            EmitBrowserConfigurationOnce(writer);
         }
     }
 

src/Components/Server.AutoPause/src/js/autopause.lib.module.ts

@@ -11,20 +11,30 @@ interface WebStartOptionsLike {
   circuit?: Record<string, unknown>;
 }
 
+type ServerStartOptionsLike = Record<string, unknown>;
+
 let config: AutoPauseConfig | undefined;
 let manager: AutoPauseManager | undefined;
 
-function beforeWebStart(options: WebStartOptionsLike): void {
-  const enabled = options.circuit?.['autoPauseEnabled'] as boolean | undefined;
+function configure(options: Record<string, unknown> | undefined): void {
+  const enabled = options?.['autoPauseEnabled'] as boolean | undefined;
   if (enabled === undefined) {
     return;
   }
   config = {
     enabled,
-    hiddenDelayMilliseconds: options.circuit?.['autoPauseHiddenDelayMilliseconds'] as number | undefined ?? 120000,
+    hiddenDelayMilliseconds: options?.['autoPauseHiddenDelayMilliseconds'] as number | undefined ?? 120000,
   };
 }
 
+function beforeWebStart(options: WebStartOptionsLike): void {
+  configure(options.circuit);
+}
+
+function beforeServerStart(options: ServerStartOptionsLike): void {
+  configure(options);
+}
+
 // Called by the framework once Blazor has started; activates auto-pause when AddAutoPause
 // enabled it. A second call disposes the previous manager so listeners never accumulate.
 function afterWebStarted(blazor: BlazorLike): void {
@@ -41,4 +51,4 @@ function afterWebStarted(blazor: BlazorLike): void {
   mgr.start();
 }
 
-export { beforeWebStart, beforeWebStart as beforeServerStart, afterWebStarted, afterWebStarted as afterServerStarted };
+export { beforeWebStart, beforeServerStart, afterWebStarted, afterWebStarted as afterServerStarted };

src/Components/Server.AutoPause/src/js/test/AutoPauseInitializer.test.ts

@@ -100,4 +100,16 @@ describe('autopause initializer', () => {
     const attached = blazor.added.filter(h => !blazor.removed.includes(h));
     expect(attached).toHaveLength(1);
   });
+
+  it('server start reads auto-pause configuration discovered during enhanced navigation', () => {
+    const blazor = createBlazor();
+
+    beforeWebStart({ circuit: { autoPauseEnabled: false } });
+    afterWebStarted(blazor);
+    expect(blazor.added).toHaveLength(0);
+
+    beforeServerStart({ autoPauseEnabled: true, autoPauseHiddenDelayMilliseconds: 100 });
+    afterServerStarted(blazor);
+    expect(blazor.added).toHaveLength(1);
+  });
 });

src/Components/Web.JS/src/Boot.Server.Common.ts

@@ -14,25 +14,20 @@ import { RootComponentManager } from './Services/RootComponentManager';
 import { WebRendererId } from './Rendering/WebRendererId';
 import { addDispatchEventMiddleware } from './Rendering/WebRendererInteropMethods';
 
-let initializersPromise: Promise<void> | undefined;
+let circuitOptionsPromise: Promise<Partial<CircuitStartOptions>> | undefined;
 let appState: string;
 let circuit: CircuitManager;
 let options: CircuitStartOptions;
 let logger: ConsoleLogger;
 let serverStartPromise: Promise<void>;
 let circuitStarting: Promise<boolean> | undefined;
 
-export function setCircuitOptions(initializersReady: Promise<Partial<CircuitStartOptions>>) {
-  if (options) {
+export function setCircuitOptions(optionsReady: Promise<Partial<CircuitStartOptions>>) {
+  if (circuitOptionsPromise) {
     throw new Error('Circuit options have already been configured.');
   }
 
-  initializersPromise = setOptions(initializersReady);
-
-  async function setOptions(initializers: Promise<Partial<CircuitStartOptions>>): Promise<void> {
-    const configuredOptions = await initializers;
-    options = resolveOptions(configuredOptions);
-  }
+  circuitOptionsPromise = optionsReady;
 }
 
 export function startServer(components: RootComponentManager<ServerComponentDescriptor>, jsEventRegistry: JSEventRegistry): Promise<void> {
@@ -46,7 +41,7 @@ export function startServer(components: RootComponentManager<ServerComponentDesc
 }
 
 async function startServerCore(components: RootComponentManager<ServerComponentDescriptor>, jsEventRegistry: JSEventRegistry, resolve: () => void, _: any) {
-  await initializersPromise;
+  options = resolveOptions(await circuitOptionsPromise);
   const jsInitializer = await fetchAndInvokeInitializers(options);
 
   appState = discoverServerPersistedState(document) || '';

src/Components/Web.JS/src/Boot.Web.ts

@@ -59,6 +59,9 @@ function boot(options?: Partial<WebStartOptions>) : Promise<void> {
     enhancedNavigationStarted: () => {
       jsEventRegistry.dispatchEvent('enhancednavigationstart', {});
     },
+    documentReceived: (source) => {
+      updateOptionsFromBrowserConfiguration(options, source);
+    },
     documentUpdated: () => {
       rootComponentManager.onDocumentUpdated();
       resetScrollIfNeeded(ScrollResetSchedule.AfterDocumentUpdate);
@@ -99,8 +102,31 @@ function boot(options?: Partial<WebStartOptions>) : Promise<void> {
 }
 
 function onInitialDomContentLoaded(options: Partial<WebStartOptions>) {
-  // Discover server-emitted browser configuration and merge into options
-  const browserConfig = discoverBrowserConfiguration(document);
+  updateOptionsFromBrowserConfiguration(options);
+
+  // Retrieve and start invoking the initializers.
+  // Blazor server options get defaults that are configured before we invoke the initializers
+  // so we do the same here.
+  const initialCircuitOptions = resolveOptions(options?.circuit || {});
+  options.circuit = initialCircuitOptions;
+  options.webAssembly = options.webAssembly || ({} as WebAssemblyStartOptions);
+  const logger = new ConsoleLogger(initialCircuitOptions.logLevel);
+  const initializersPromise = fetchAndInvokeInitializers(options, logger);
+  setCircuitOptions(resolveConfiguredOptions(initializersPromise, initialCircuitOptions));
+  setWebAssemblyOptions(resolveConfiguredOptions(initializersPromise, options.webAssembly));
+
+  registerAllComponentDescriptors(document);
+
+  rootComponentManager.onDocumentUpdated();
+
+  // Initialize client-side validation if the page has validatable fields.
+  initFormValidationIfNeeded();
+
+  callAfterStartedCallbacks(initializersPromise);
+}
+
+function updateOptionsFromBrowserConfiguration(options: Partial<WebStartOptions>, source: Document = document): void {
+  const browserConfig = discoverBrowserConfiguration(source);
   if (browserConfig) {
     if (browserConfig.logLevel !== undefined) {
       options.logLevel = browserConfig.logLevel;
@@ -141,37 +167,16 @@ function onInitialDomContentLoaded(options: Partial<WebStartOptions>) {
         }
       }
     }
-  }
-
-  // Retrieve and start invoking the initializers.
-  // Blazor server options get defaults that are configured before we invoke the initializers
-  // so we do the same here.
-  const initialCircuitOptions = resolveOptions(options?.circuit || {});
-  options.circuit = initialCircuitOptions;
-  options.webAssembly = options.webAssembly || ({} as WebAssemblyStartOptions);
-  const logger = new ConsoleLogger(initialCircuitOptions.logLevel);
-  const initializersPromise = fetchAndInvokeInitializers(options, logger);
-  setCircuitOptions(resolveConfiguredOptions(initializersPromise, initialCircuitOptions));
-  setWebAssemblyOptions(resolveConfiguredOptions(initializersPromise, options.webAssembly));
 
-  // If BrowserConfiguration had WebAssembly server options, apply them
-  // before registering component descriptors, since registration triggers
-  // WebAssembly platform loading which captures these options.
-  if (browserConfig?.webAssembly) {
-    rootComponentManager.setWebAssemblyOptions({
-      environmentName: browserConfig.webAssembly.environmentName ?? '',
-      environmentVariables: browserConfig.webAssembly.environmentVariables ?? {},
-    });
+    // Apply WebAssembly server options before processing component descriptors, since
+    // registration can trigger platform loading that captures these options.
+    if (browserConfig.webAssembly) {
+      rootComponentManager.setWebAssemblyOptions({
+        environmentName: browserConfig.webAssembly.environmentName ?? '',
+        environmentVariables: browserConfig.webAssembly.environmentVariables ?? {},
+      });
+    }
   }
-
-  registerAllComponentDescriptors(document);
-
-  rootComponentManager.onDocumentUpdated();
-
-  // Initialize client-side validation if the page has validatable fields.
-  initFormValidationIfNeeded();
-
-  callAfterStartedCallbacks(initializersPromise);
 }
 
 function initFormValidationIfNeeded(): void {

src/Components/Web.JS/src/Services/NavigationEnhancement.ts

@@ -44,6 +44,7 @@ let currentContentUrl = location.href;
 
 export interface NavigationEnhancementCallbacks {
   enhancedNavigationStarted: () => void;
+  documentReceived: (source: Document) => void;
   documentUpdated: () => void;
   enhancedNavigationCompleted: () => void;
 }
@@ -309,6 +310,7 @@ export async function performEnhancedPageLoad(internalDestinationHref: string, i
       if (responseContentType?.startsWith('text/html') && initialContent) {
         // For HTML responses, regardless of the status code, display it
         const parsedHtml = new DOMParser().parseFromString(initialContent, 'text/html');
+        navigationEnhancementCallbacks.documentReceived(parsedHtml);
         synchronizeDomContent(document, parsedHtml);
         navigationEnhancementCallbacks.documentUpdated();
       } else if (responseContentType?.startsWith('text/') && initialContent) {

src/Components/test/E2ETest/ServerRenderingTests/BlazorWebJsInitializersTest.cs

@@ -81,6 +81,38 @@ public void InitializersRunsClassicInitializersWhenEnabled(bool streaming, bool
         }
     }
 
+    [Fact]
+    public void ServerInitializerActivatedAfterEnhancedNavigationFromStaticPage()
+    {
+        Navigate($"{ServerPathBase}/initializers?streaming=false&wasm=false&server=false&auto-pause=true&auto-pause-delay-ms=10");
+
+        Browser.True(() => (bool)((IJavaScriptExecutor)Browser).ExecuteScript(
+            "return typeof Blazor.pauseCircuit === 'undefined'"));
+
+        ((IJavaScriptExecutor)Browser).ExecuteScript(
+            "Blazor.navigateTo('persistent-state/server-pause?auto-pause=true&auto-pause-delay-ms=10')");
+
+        Browser.Exists(By.Id("render-mode-interactive"));
+        Browser.True(() => (bool)((IJavaScriptExecutor)Browser).ExecuteScript(
+            "return typeof Blazor.pauseCircuit === 'function'"));
+
+        ((IJavaScriptExecutor)Browser).ExecuteScript(
+            """
+            window.autoPauseCallCount = 0;
+            const pauseCircuit = Blazor.pauseCircuit;
+            Blazor.pauseCircuit = (...args) => {
+                window.autoPauseCallCount++;
+                return pauseCircuit(...args);
+            };
+            Object.defineProperty(document, 'visibilityState', { configurable: true, get: () => 'hidden' });
+            Object.defineProperty(document, 'hidden', { configurable: true, get: () => true });
+            document.dispatchEvent(new Event('visibilitychange'));
+            """);
+
+        Browser.Equal(1L, () => (long)((IJavaScriptExecutor)Browser).ExecuteScript(
+            "return window.autoPauseCallCount"));
+    }
+
     private void EnableClassicInitializers(IWebDriver browser)
     {
         browser.Navigate().GoToUrl($"{new Uri(_serverFixture.RootUri, ServerPathBase)}/");

src/Components/test/testassets/Components.TestServer/RazorComponents/App.razor

@@ -22,6 +22,24 @@
     [SupplyParameterFromQuery(Name = "appSetsEventArgsPath")]
     public bool AppSetsEventArgsPath { get; set; }
 
+    [Parameter]
+    [SupplyParameterFromQuery(Name = "auto-pause")]
+    public bool AutoPause { get; set; }
+
+    [Parameter]
+    [SupplyParameterFromQuery(Name = "auto-pause-delay-ms")]
+    public int AutoPauseDelayMs { get; set; }
+
+    private BrowserOptions AutoPauseConfig
+    {
+        get
+        {
+            var options = new BrowserOptions();
+            options.AddAutoPause(pause => pause.HiddenDelay = TimeSpan.FromMilliseconds(AutoPauseDelayMs > 0 ? AutoPauseDelayMs : 200));
+            return options;
+        }
+    }
+
     [Parameter]
     [SupplyParameterFromQuery(Name = "useOnNavigateAsync")]
     public bool ShouldDelayOnNavigateAsync { get; set; }
@@ -104,6 +122,11 @@
     <HeadOutlet />
 </head>
 <body>
+    @if (AutoPause)
+    {
+        <ConfigureBrowser Options="@AutoPauseConfig" />
+    }
+
     @if(string.Equals(UseCustomRouter, "true", StringComparison.OrdinalIgnoreCase))
     {
         <CustomRouter AppAssembly="@typeof(App).Assembly">