diff --git a/aspnetcore/blazor/fundamentals/environments.md b/aspnetcore/blazor/fundamentals/environments.md
index 11c6dc2301b6..57676914bb81 100644
--- a/aspnetcore/blazor/fundamentals/environments.md
+++ b/aspnetcore/blazor/fundamentals/environments.md
@@ -71,6 +71,29 @@ For more information on how to configure the server-side environment, see <xref:
 
 The following example starts Blazor in the `Staging` environment if the hostname includes `localhost`. Otherwise, the environment is set to its default value.
 
+:::moniker range=">= aspnetcore-8.0"
+
+Blazor Web App:
+
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  if (window.location.hostname.includes("localhost")) {
+    Blazor.start({
+      webAssembly: {
+        environment: "Staging"
+      }
+    });
+  } else {
+    Blazor.start();
+  }
+</script>
+```
+
+Standalone Blazor WebAssembly:
+
+:::moniker-end
+
 ```html
 <script src="{BLAZOR SCRIPT}" autostart="false"></script>
 <script>
diff --git a/aspnetcore/blazor/fundamentals/logging.md b/aspnetcore/blazor/fundamentals/logging.md
index ad1d9af18efd..30e5b287b722 100644
--- a/aspnetcore/blazor/fundamentals/logging.md
+++ b/aspnetcore/blazor/fundamentals/logging.md
@@ -676,7 +676,28 @@ For the `configureLogging` log level value, pass the argument as either the stri
 | <xref:Microsoft.Extensions.Logging.LogLevel.Critical>    | `critical`     | 5               |
 | <xref:Microsoft.Extensions.Logging.LogLevel.None>        | `none`         | 6               |
 
-Example 1: Set the <xref:Microsoft.Extensions.Logging.LogLevel.Information> log level with a string value:
+Example 1: Set the <xref:Microsoft.Extensions.Logging.LogLevel.Information> log level with a string value.
+
+:::moniker range=">= aspnetcore-8.0"
+
+Blazor Web App:
+
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  Blazor.start({
+    circuit: {
+      configureSignalR: function (builder) {
+        builder.configureLogging("information");
+      }
+    }
+  });
+</script>
+```
+
+Blazor Server:
+
+:::moniker-end
 
 ```html
 <script src="{BLAZOR SCRIPT}" autostart="false"></script>
@@ -691,10 +712,31 @@ Example 1: Set the <xref:Microsoft.Extensions.Logging.LogLevel.Information> log
 
 In the preceding example, the `{BLAZOR SCRIPT}` placeholder is the Blazor script path and file name.
 
-Example 2: Set the <xref:Microsoft.Extensions.Logging.LogLevel.Information> log level with an integer value:
+Example 2: Set the <xref:Microsoft.Extensions.Logging.LogLevel.Information> log level with an integer value.
+
+:::moniker range=">= aspnetcore-8.0"
+
+Blazor Web App:
+
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  Blazor.start({
+    circuit: {
+      configureSignalR: function (builder) {
+        builder.configureLogging("information");
+      }
+    }
+  });
+</script>
+```
+
+Blazor Server:
+
+:::moniker-end
 
 ```html
-<script src="{BLAZOR SCRIPT}"></script>
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
 <script>
   Blazor.start({
     configureSignalR: function (builder) {
diff --git a/aspnetcore/blazor/fundamentals/signalr.md b/aspnetcore/blazor/fundamentals/signalr.md
index eb15bbbb3582..f4d50245d7cb 100644
--- a/aspnetcore/blazor/fundamentals/signalr.md
+++ b/aspnetcore/blazor/fundamentals/signalr.md
@@ -735,19 +735,37 @@ Configure the following values for the client:
 * `withServerTimeout`: Configures the server timeout in milliseconds. If this timeout elapses without receiving any messages from the server, the connection is terminated with an error. The default timeout value is 30 seconds. The server timeout should be at least double the value assigned to the Keep-Alive interval (`withKeepAliveInterval`).
 * `withKeepAliveInterval`: Configures the Keep-Alive interval in milliseconds (default interval at which to ping the server). This setting allows the server to detect hard disconnects, such as when a client unplugs their computer from the network. The ping occurs at most as often as the server pings. If the server pings every five seconds, assigning a value lower than `5000` (5 seconds) pings every five seconds. The default value is 15 seconds. The Keep-Alive interval should be less than or equal to half the value assigned to the server timeout (`withServerTimeout`).
 
-The following example for the `App.razor` file (Blazor Web App) shows the assignment of default values:
+The following example for the `App.razor` file (Blazor Web App) shows the assignment of default values.
+
+Blazor Web App:
 
 ```html
 <script src="{BLAZOR SCRIPT}" autostart="false"></script>
 <script>
   Blazor.start({
-    configureSignalR: function (builder) {
-      builder.withServerTimeout(30000).withKeepAliveInterval(15000);
+    circuit: {
+      configureSignalR: function (builder) {
+        builder.withServerTimeout(30000).withKeepAliveInterval(15000);
+      }
     }
   });
 </script>
 ```
 
+The following example for the `Pages/_Host.cshtml` file (Blazor Server, all versions except ASP.NET Core 6.0) or `Pages/_Layout.cshtml` file (Blazor Server, ASP.NET Core 6.0).
+
+Blazor Server:
+
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  Blazor.start({
+    configureSignalR: function (builder) {
+        builder.withServerTimeout(30000).withKeepAliveInterval(15000);
+  });
+</script>
+```
+
 In the preceding example, the `{BLAZOR SCRIPT}` placeholder is the Blazor script path and file name.
 
 When creating a hub connection in a component, set the <xref:Microsoft.AspNetCore.SignalR.Client.HubConnection.ServerTimeout> (default: 30 seconds) and <xref:Microsoft.AspNetCore.SignalR.Client.HubConnection.KeepAliveInterval> (default: 15 seconds) on the <xref:Microsoft.AspNetCore.SignalR.Client.HubConnectionBuilder>. Set the <xref:Microsoft.AspNetCore.SignalR.Client.HubConnection.HandshakeTimeout> (default: 15 seconds) on the built <xref:Microsoft.AspNetCore.SignalR.Client.HubConnection>. The following example shows the assignment of default values:
@@ -843,6 +861,28 @@ To modify the connection events, register callbacks for the following connection
 
 **Both `onConnectionDown` and `onConnectionUp` must be specified.**
 
+:::moniker range=">= aspnetcore-8.0"
+
+Blazor Web App:
+
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  Blazor.start({
+    circuit: {
+      reconnectionHandler: {
+        onConnectionDown: (options, error) => console.error(error),
+        onConnectionUp: () => console.log("Up, up, and away!")
+      }
+    }
+  });
+</script>
+```
+
+Blazor Server:
+
+:::moniker-end
+
 ```html
 <script src="{BLAZOR SCRIPT}" autostart="false"></script>
 <script>
@@ -887,7 +927,83 @@ The default reconnection behavior requires the user to take manual action to ref
 
 In the preceding example, the `{BLAZOR SCRIPT}` placeholder is the Blazor script path and file name.
 
-`wwwroot/boot.js`:
+Create the following `wwwroot/boot.js` file.
+
+:::moniker-end
+
+:::moniker range=">= aspnetcore-8.0"
+
+Blazor Web App:
+
+```javascript
+(() => {
+  const maximumRetryCount = 3;
+  const retryIntervalMilliseconds = 5000;
+  const reconnectModal = document.getElementById('reconnect-modal');
+  
+  const startReconnectionProcess = () => {
+    reconnectModal.style.display = 'block';
+
+    let isCanceled = false;
+
+    (async () => {
+      for (let i = 0; i < maximumRetryCount; i++) {
+        reconnectModal.innerText = `Attempting to reconnect: ${i + 1} of ${maximumRetryCount}`;
+
+        await new Promise(resolve => setTimeout(resolve, retryIntervalMilliseconds));
+
+        if (isCanceled) {
+          return;
+        }
+
+        try {
+          const result = await Blazor.reconnect();
+          if (!result) {
+            // The server was reached, but the connection was rejected; reload the page.
+            location.reload();
+            return;
+          }
+
+          // Successfully reconnected to the server.
+          return;
+        } catch {
+          // Didn't reach the server; try again.
+        }
+      }
+
+      // Retried too many times; reload the page.
+      location.reload();
+    })();
+
+    return {
+      cancel: () => {
+        isCanceled = true;
+        reconnectModal.style.display = 'none';
+      },
+    };
+  };
+
+  let currentReconnectionProcess = null;
+
+  Blazor.start({
+    circuit: {
+      reconnectionHandler: {
+        onConnectionDown: () => currentReconnectionProcess ??= startReconnectionProcess(),
+        onConnectionUp: () => {
+          currentReconnectionProcess?.cancel();
+          currentReconnectionProcess = null;
+        }
+      }
+    }
+  });
+})();
+```
+
+Blazor Server:
+
+:::moniker-end
+
+:::moniker range=">= aspnetcore-7.0"
 
 ```javascript
 (() => {
@@ -945,8 +1061,8 @@ In the preceding example, the `{BLAZOR SCRIPT}` placeholder is the Blazor script
       onConnectionUp: () => {
         currentReconnectionProcess?.cancel();
         currentReconnectionProcess = null;
-      },
-    },
+      }
+    }
   });
 })();
 ```
@@ -959,6 +1075,28 @@ For more information on Blazor startup, see <xref:blazor/fundamentals/startup>.
 
 To adjust the reconnection retry count and interval, set the number of retries (`maxRetries`) and period in milliseconds permitted for each retry attempt (`retryIntervalMilliseconds`).
 
+:::moniker range=">= aspnetcore-8.0"
+
+Blazor Web App:
+
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  Blazor.start({
+    circuit: {
+      reconnectionOptions: {
+        maxRetries: 3,
+        retryIntervalMilliseconds: 2000
+      }
+    }
+  });
+</script>
+```
+
+Blazor Server:
+
+:::moniker-end
+
 ```html
 <script src="{BLAZOR SCRIPT}" autostart="false"></script>
 <script>
diff --git a/aspnetcore/blazor/fundamentals/startup.md b/aspnetcore/blazor/fundamentals/startup.md
index 0b716762ba41..ff0fd2a7677a 100644
--- a/aspnetcore/blazor/fundamentals/startup.md
+++ b/aspnetcore/blazor/fundamentals/startup.md
@@ -20,29 +20,59 @@ For general guidance on ASP.NET Core app configuration for server-side developme
 
 :::moniker range=">= aspnetcore-8.0"
 
-The Blazor startup process is automatic and asynchronous via the Blazor script (`blazor.*.js`), where `*` is either `web` for a Blazor Web App or `webassembly` for a Blazor WebAssembly app. The Blazor `<script>` tag is found in the `wwwroot/index.html` file of a Blazor WebAssembly app or client of a Blazor Web App, or the `App.razor` file of a Blazor Web App.
+The Blazor startup process is automatic and asynchronous via the Blazor script (`blazor.*.js`), where the `*` placeholder is:
+
+* `web` for a Blazor Web App
+* `server` for a Blazor Server app
+* `webassembly` for a Blazor WebAssembly app
 
 :::moniker-end
 
-:::moniker range=">= aspnetcore-7.0 < aspnetcore-8.0"
+:::moniker range="< aspnetcore-8.0"
+
+The Blazor startup process is automatic and asynchronous via the Blazor script (`blazor.*.js`), where the `*` placeholder is:
 
-The Blazor startup process is automatic and asynchronous via the Blazor script (`blazor.*.js`), where `*` is either `server` for a Blazor Server app or `webassembly` for a Blazor WebAssembly app. The Blazor `<script>` tag is found in the `wwwroot/index.html` file of a Blazor WebAssembly app or the `Pages/_Host.cshtml` file of a Blazor Server app.
+* `server` for a Blazor Server app
+* `webassembly` for a Blazor WebAssembly app
 
 :::moniker-end
 
-:::moniker range=">= aspnetcore-6.0 < aspnetcore-7.0"
+For the location of the script, see <xref:blazor/project-structure#location-of-the-blazor-script>.
 
-The Blazor startup process is automatic and asynchronous via the Blazor script (`blazor.*.js`), where `*` is either `server` for a Blazor Server app or `webassembly` for a Blazor WebAssembly app. The Blazor `<script>` tag is found in the `wwwroot/index.html` file of a Blazor WebAssembly app or the `Pages/_Layout.cshtml` file of a Blazor Server app.
+To manually start Blazor:
 
-:::moniker-end
+:::moniker range=">= aspnetcore-8.0"
 
-:::moniker range="< aspnetcore-6.0"
+Blazor Web App:
 
-The Blazor startup process is automatic and asynchronous via the Blazor script (`blazor.*.js`), where `*` is either `server` for a Blazor Server app or `webassembly` for a Blazor WebAssembly app. The Blazor `<script>` tag is found in the `wwwroot/index.html` file of a Blazor WebAssembly app or the `Pages/_Host.cshtml` file of a Blazor Server app.
+* Add an `autostart="false"` attribute and value to the Blazor `<script>` tag.
+* Place a script that calls `Blazor.start()` after the Blazor `<script>` tag and inside the closing `</body>` tag.
+* Place static server rendering options in the `ssr` property.
+* Place server-side Blazor-SignalR circuit options in the `circuit` property.
+* Place client-side WebAssembly options in the `webAssembly` property.
 
-:::moniker-end
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  ...
+  Blazor.start({
+    ssr: {
+      ...
+    },
+    circuit: {
+      ...
+    },
+    webAssembly: {
+      ...
+    }
+  });
+  ...
+</script>
+```
 
-To manually start Blazor:
+Blazor Server:
+
+:::moniker-end
 
 * Add an `autostart="false"` attribute and value to the Blazor `<script>` tag.
 * Place a script that calls `Blazor.start()` after the Blazor `<script>` tag and inside the closing `</body>` tag.
@@ -260,6 +290,33 @@ The `loadBootResource` function can return a URI string to override the loading
 
 The `{TARGET FRAMEWORK}` placeholder is the target framework moniker (for example, `net7.0`). The `{VERSION}` placeholder is the shared framework version (for example, `7.0.0`).
 
+:::moniker range=">= aspnetcore-8.0"
+
+Blazor Web App:
+
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  Blazor.start({
+    webAssembly: {
+      loadBootResource: function (type, name, defaultUri, integrity) {
+        console.log(`Loading: '${type}', '${name}', '${defaultUri}', '${integrity}'`);
+        switch (type) {
+          case 'dotnetjs':
+          case 'dotnetwasm':
+          case 'timezonedata':
+            return `https://cdn.example.com/blazorwebassembly/{VERSION}/${name}`;
+        }
+      }
+    }
+  });
+</script>
+```
+
+Standalone Blazor WebAssembly:
+
+:::moniker-end
+
 ```html
 <script src="{BLAZOR SCRIPT}" autostart="false"></script>
 <script>
@@ -281,6 +338,35 @@ In the preceding example, the `{BLAZOR SCRIPT}` placeholder is the Blazor script
 
 To customize more than just the URLs for boot resources, the `loadBootResource` function can call `fetch` directly and return the result. The following example adds a custom HTTP header to the outbound requests. To retain the default integrity checking behavior, pass through the `integrity` parameter.
 
+:::moniker range=">= aspnetcore-8.0"
+
+Blazor Web App:
+
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  Blazor.start({
+    webAssembly: {
+      loadBootResource: function (type, name, defaultUri, integrity) {
+        if (type == 'dotnetjs') {
+          return null;
+        } else {
+          return fetch(defaultUri, {
+            cache: 'no-cache',
+            integrity: integrity,
+            headers: { 'Custom-Header': 'Custom Value' }
+          });
+        }
+      }
+    }
+  });
+</script>
+```
+
+Standalone Blazor WebAssembly:
+
+:::moniker-end
+
 ```html
 <script src="{BLAZOR SCRIPT}" autostart="false"></script>
 <script>
@@ -466,6 +552,23 @@ To configure the .NET WebAssembly runtime, use the `configureRuntime` function w
 
 The following example sets an environment variable, `CONFIGURE_RUNTIME`, to `true`:
 
+Blazor Web App:
+
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+<script>
+  Blazor.start({
+    webAssembly: {
+      configureRuntime: dotnet => {
+        dotnet.withEnvironmentVariable("CONFIGURE_RUNTIME", "true");
+      }
+    }
+  });
+</script>
+```
+
+Standalone Blazor WebAssembly:
+
 ```html
 <script src="{BLAZOR SCRIPT}" autostart="false"></script>
 <script>
@@ -489,7 +592,7 @@ The .NET runtime instance can be accessed from `Blazor.runtime`.
 
 *This section applies to Blazor Web Apps.*
 
-To disable enhanced navigation and form handling, set `disableDomPreservation` to `true` for `Blazor.start`:
+To disable enhanced navigation and form handling, set `disableDomPreservation` to `true` for `Blazor.start`.
 
 ```html
 <script src="{BLAZOR SCRIPT}" autostart="false"></script>
diff --git a/aspnetcore/blazor/globalization-localization.md b/aspnetcore/blazor/globalization-localization.md
index e98cd4bec49c..3da6548b0a86 100644
--- a/aspnetcore/blazor/globalization-localization.md
+++ b/aspnetcore/blazor/globalization-localization.md
@@ -261,23 +261,41 @@ By default, the Intermediate Language (IL) Linker configuration for client-side
 
 The app's culture can be set in JavaScript when Blazor starts with the `applicationCulture` Blazor start option. The following example configures the app to launch using the United States English (`en-US`) culture.
 
-* Prevent Blazor autostart by adding `autostart="false"` to Blazor's script tag:
+Prevent Blazor autostart by adding `autostart="false"` to Blazor's script tag:
 
-  ```html
-  <script src="{BLAZOR SCRIPT}" autostart="false"></script>
-  ```
+```html
+<script src="{BLAZOR SCRIPT}" autostart="false"></script>
+```
+
+In the preceding example, the `{BLAZOR SCRIPT}` placeholder is the Blazor script path and file name.
+
+Add the following `<script>` block after Blazor's `<script>` tag and before the closing `</body>` tag:
 
-  In the preceding example, the `{BLAZOR SCRIPT}` placeholder is the Blazor script path and file name.
+:::moniker range=">= aspnetcore-8.0"
 
-* Add the following `<script>` block after Blazor's `<script>` tag and before the closing `</body>` tag:
+Blazor Web App:
 
-  ```html
-  <script>
-    Blazor.start({
+```html
+<script>
+  Blazor.start({
+    webAssembly: {
       applicationCulture: 'en-US'
-    });
-  </script>
-  ```
+    }
+  });
+</script>
+```
+
+Standalone Blazor WebAssembly:
+
+:::moniker-end
+
+```html
+<script>
+  Blazor.start({
+    applicationCulture: 'en-US'
+  });
+</script>
+```
 
 The value for `applicationCulture` must conform to the [BCP-47 language tag format](https://www.rfc-editor.org/info/bcp47). For more information on Blazor startup, see <xref:blazor/fundamentals/startup>.
 
diff --git a/aspnetcore/blazor/host-and-deploy/server.md b/aspnetcore/blazor/host-and-deploy/server.md
index 5cb89cd10381..2492e792b17f 100644
--- a/aspnetcore/blazor/host-and-deploy/server.md
+++ b/aspnetcore/blazor/host-and-deploy/server.md
@@ -128,7 +128,23 @@ If a deployed app frequently displays the reconnection UI due to ping timeouts c
   >
   > In the following example, a custom value of 60 seconds is used for the server timeout.
 
-  In the [startup configuration](xref:blazor/fundamentals/startup) of a server-side Blazor app after the Blazor script (`blazor.*.js`) `<script>` tag:
+  In the [startup configuration](xref:blazor/fundamentals/startup) of a server-side Blazor app after the Blazor script (`blazor.*.js`) `<script>` tag.
+
+  Blazor Web App:
+
+  ```html
+  <script>
+    Blazor.start({
+      circuit: {
+        configureSignalR: function (builder) {
+          builder.withServerTimeout(60000);
+        }
+      }
+    });
+  </script>
+  ```
+
+  Blazor Server:
 
   ```html
   <script>
diff --git a/aspnetcore/blazor/host-and-deploy/webassembly.md b/aspnetcore/blazor/host-and-deploy/webassembly.md
index a1b0e40639f3..f740565c790f 100644
--- a/aspnetcore/blazor/host-and-deploy/webassembly.md
+++ b/aspnetcore/blazor/host-and-deploy/webassembly.md
@@ -169,48 +169,82 @@ Blazor relies on the host to serve the appropriate compressed files. When using
 * For IIS `web.config` compression configuration, see the [IIS: Brotli and Gzip compression](#brotli-and-gzip-compression) section. 
 * When hosting on static hosting solutions that don't support statically-compressed file content negotiation, consider configuring the app to fetch and decode Brotli compressed files:
 
-  * Obtain the JavaScript Brotli decoder from the [google/brotli GitHub repository](https://github.com/google/brotli). The minified decoder file is named `decode.min.js` and found in the repository's [`js` folder](https://github.com/google/brotli/tree/master/js).
+Obtain the JavaScript Brotli decoder from the [google/brotli GitHub repository](https://github.com/google/brotli). The minified decoder file is named `decode.min.js` and found in the repository's [`js` folder](https://github.com/google/brotli/tree/master/js).
   
-    > [!NOTE]
-    > If the minified version of the `decode.js` script (`decode.min.js`) fails, try using the unminified version (`decode.js`) instead.
+> [!NOTE]
+> If the minified version of the `decode.js` script (`decode.min.js`) fails, try using the unminified version (`decode.js`) instead.
 
-  * Update the app to use the decoder.
+Update the app to use the decoder.
     
-    In the `wwwroot/index.html` file, set `autostart` to `false` on Blazor's `<script>` tag:
+In the `wwwroot/index.html` file, set `autostart` to `false` on Blazor's `<script>` tag:
     
-    ```html
-    <script src="_framework/blazor.webassembly.js" autostart="false"></script>
-    ```
+```html
+<script src="_framework/blazor.webassembly.js" autostart="false"></script>
+```
     
-    After Blazor's `<script>` tag and before the closing `</body>` tag, add the following JavaScript code `<script>` block:
-  
-    ```html
-    <script type="module">
-      import { BrotliDecode } from './decode.min.js';
-      Blazor.start({
-        loadBootResource: function (type, name, defaultUri, integrity) {
-          if (type !== 'dotnetjs' && location.hostname !== 'localhost' && type !== 'configuration' && type !== 'manifest') {
-            return (async function () {
-              const response = await fetch(defaultUri + '.br', { cache: 'no-cache' });
-              if (!response.ok) {
-                throw new Error(response.statusText);
-              }
-              const originalResponseBuffer = await response.arrayBuffer();
-              const originalResponseArray = new Int8Array(originalResponseBuffer);
-              const decompressedResponseArray = BrotliDecode(originalResponseArray);
-              const contentType = type === 
-                'dotnetwasm' ? 'application/wasm' : 'application/octet-stream';
-              return new Response(decompressedResponseArray, 
-                { headers: { 'content-type': contentType } });
-            })();
-          }
+After Blazor's `<script>` tag and before the closing `</body>` tag, add the following JavaScript code `<script>` block.
+
+:::moniker range=">= aspnetcore-8.0"
+
+Blazor Web App:
+
+```html
+<script type="module">
+  import { BrotliDecode } from './decode.min.js';
+  Blazor.start({
+    webAssembly: {
+      loadBootResource: function (type, name, defaultUri, integrity) {
+        if (type !== 'dotnetjs' && location.hostname !== 'localhost' && type !== 'configuration' && type !== 'manifest') {
+          return (async function () {
+            const response = await fetch(defaultUri + '.br', { cache: 'no-cache' });
+            if (!response.ok) {
+              throw new Error(response.statusText);
+            }
+            const originalResponseBuffer = await response.arrayBuffer();
+            const originalResponseArray = new Int8Array(originalResponseBuffer);
+            const decompressedResponseArray = BrotliDecode(originalResponseArray);
+            const contentType = type === 
+              'dotnetwasm' ? 'application/wasm' : 'application/octet-stream';
+            return new Response(decompressedResponseArray, 
+              { headers: { 'content-type': contentType } });
+          })();
         }
-      });
-    </script>
-    ```
+      }
+    }
+  });
+</script>
+```
+
+Standalone Blazor WebAssembly:
+
+:::moniker-end
 
-    For more information on loading boot resources, see <xref:blazor/fundamentals/startup#load-boot-resources>.
+```html
+<script type="module">
+  import { BrotliDecode } from './decode.min.js';
+  Blazor.start({
+    loadBootResource: function (type, name, defaultUri, integrity) {
+      if (type !== 'dotnetjs' && location.hostname !== 'localhost' && type !== 'configuration') {
+        return (async function () {
+          const response = await fetch(defaultUri + '.br', { cache: 'no-cache' });
+          if (!response.ok) {
+            throw new Error(response.statusText);
+          }
+          const originalResponseBuffer = await response.arrayBuffer();
+          const originalResponseArray = new Int8Array(originalResponseBuffer);
+          const decompressedResponseArray = BrotliDecode(originalResponseArray);
+          const contentType = type === 
+            'dotnetwasm' ? 'application/wasm' : 'application/octet-stream';
+          return new Response(decompressedResponseArray, 
+            { headers: { 'content-type': contentType } });
+        })();
+      }
+    }
+  });
+</script>
+```
 
+For more information on loading boot resources, see <xref:blazor/fundamentals/startup#load-boot-resources>.
 
 :::moniker range=">= aspnetcore-8.0"
 
diff --git a/aspnetcore/blazor/project-structure.md b/aspnetcore/blazor/project-structure.md
index e0d4e1719818..7809721fb4c0 100644
--- a/aspnetcore/blazor/project-structure.md
+++ b/aspnetcore/blazor/project-structure.md
@@ -539,6 +539,62 @@ The project structure of the client-side app in a hosted Blazor Webassembly solu
 
 :::moniker-end
 
+## Location of the Blazor script
+
+The script is served from an embedded resource in the ASP.NET Core shared framework.
+
+:::moniker range=">= aspnetcore-8.0"
+
+In a Blazor Web App, the Blazor script is located in the `Components/App.razor` file:
+
+```
+<script src="_framework/blazor.web.js"></script>
+```
+
+In a Blazor Server app, the Blazor script is located in the `Pages/_Host.cshtml` file:
+
+```
+<script src="_framework/blazor.server.js"></script>
+```
+
+:::moniker-end
+
+:::moniker range=">= aspnetcore-7.0 < aspnetcore-8.0"
+
+In a Blazor Server app, the Blazor script is located in the `Pages/_Host.cshtml` file:
+
+```
+<script src="_framework/blazor.server.js"></script>
+```
+
+:::moniker-end
+
+:::moniker range=">= aspnetcore-6.0 < aspnetcore-7.0"
+
+In a Blazor Server app, the Blazor script is located in the `Pages/_Layout.cshtml` file:
+
+```
+<script src="_framework/blazor.server.js"></script>
+```
+
+:::moniker-end
+
+:::moniker range="< aspnetcore-6.0"
+
+In a Blazor Server app, the Blazor script is located in the `Pages/_Host.cshtml` file:
+
+```
+<script src="_framework/blazor.server.js"></script>
+```
+
+:::moniker-end
+
+In a Blazor WebAssembly app, the Blazor script content is located in the `wwwroot/index.html` file:
+
+```
+<script src="_framework/blazor.webassembly.js"></script>
+```
+
 ## Location of `<head>` and `<body>` content
 
 :::moniker range=">= aspnetcore-8.0"
diff --git a/aspnetcore/migration/70-80.md b/aspnetcore/migration/70-80.md
index bc2fc70de7a4..788404aa08e1 100644
--- a/aspnetcore/migration/70-80.md
+++ b/aspnetcore/migration/70-80.md
@@ -77,14 +77,29 @@ In the project file, update each [`Microsoft.AspNetCore.*`](https://www.nuget.or
 
 The following migration scenarios are covered:
 
-* [Adopt Blazor Web App conventions](#adopt-blazor-web-app-conventions)
+* [Update a Blazor Server app](#update-a-blazor-server-app)
+* [Adopt all Blazor Web App conventions](#adopt-all-blazor-web-app-conventions)
 * [Convert a Blazor Server app into a Blazor Web App](#convert-a-blazor-server-app-into-a-blazor-web-app)
+* [Update a Blazor WebAssembly app](#update-a-blazor-webassembly-app)
 * [Convert a hosted Blazor WebAssembly app into a Blazor Web App](#convert-a-hosted-blazor-webassembly-app-into-a-blazor-web-app)
 * [Update service and endpoint option configuration](#update-service-and-endpoint-option-configuration)
 
 For guidance on adding Blazor support to an ASP.NET Core app, see <xref:blazor/components/integration#add-blazor-support-to-an-aspnet-core-app>.
 
-### Adopt Blazor Web App conventions
+### Update a Blazor Server app
+
+We recommend using Blazor Web Apps in .NET 8, but Blazor Server is supported. To continue using Blazor Server with .NET 8, follow the guidance in the first three sections of this article:
+
+* [Update the .NET SDK version in `global.json`](#update-the-net-sdk-version-in-globaljson)
+* [Update the target framework](#update-the-target-framework)
+* [Update package references](#update-package-references)
+
+New Blazor features introduced for Blazor Web Apps aren't available to a Blazor Server app updated to run under .NET 8. If you wish to adopt the new .NET 8 Blazor features, follow the guidance in either of the following sections:
+
+* [Adopt all Blazor Web App conventions](#adopt-all-blazor-web-app-conventions)
+* [Convert a Blazor Server app into a Blazor Web App](#convert-a-blazor-server-app-into-a-blazor-web-app)
+
+### Adopt all Blazor Web App conventions
 
 To optionally adopt all of the new Blazor Web App conventions, we recommend the following process:
 
@@ -99,7 +114,7 @@ New .NET 8 features are covered in <xref:aspnetcore-8#blazor>. When updating an
 Blazor Server apps are supported in .NET 8 without any code changes. Use the following guidance to convert a Blazor Server app into an equivalent .NET 8 Blazor Web App, which makes all of the [new .NET 8 features](xref:aspnetcore-8#blazor) available.
 
 > [!IMPORTANT]
-> This section focuses on the minimal changes required to convert a .NET 7 Blazor Server app into a .NET 8 Blazor Web App. To adopt all of the new Blazor Web App conventions, follow the guidance in the [Adopt Blazor Web App conventions](#adopt-blazor-web-app-conventions) section. 
+> This section focuses on the minimal changes required to convert a .NET 7 Blazor Server app into a .NET 8 Blazor Web App. To adopt all of the new Blazor Web App conventions, follow the guidance in the [Adopt all Blazor Web App conventions](#adopt-all-blazor-web-app-conventions) section. 
 
 1. Follow the guidance in the first three sections of this article:
 
@@ -274,12 +289,20 @@ Blazor Server apps are supported in .NET 8 without any code changes. Use the fol
 
    For more information, see <xref:blazor/components/render-modes?view=aspnetcore-8.0&preserve-view=true#prerendering>.
 
+### Update a Blazor WebAssembly app
+
+Follow the guidance in the first three sections of this article:
+
+* [Update the .NET SDK version in `global.json`](#update-the-net-sdk-version-in-globaljson)
+* [Update the target framework](#update-the-target-framework)
+* [Update package references](#update-package-references)
+
 ### Convert a hosted Blazor WebAssembly app into a Blazor Web App
 
 Blazor WebAssembly apps are supported in .NET 8 without any code changes. Use the following guidance to convert an ASP.NET Core hosted Blazor WebAssembly app into an equivalent .NET 8 Blazor Web App, which makes all of the [new .NET 8 features](xref:aspnetcore-8#blazor) available.
 
 > [!IMPORTANT]
-> This section focuses on the minimal changes required to convert a .NET 7 ASP.NET Core hosted Blazor WebAssembly app into a .NET 8 Blazor Web App. To adopt all of the new Blazor Web App conventions, follow the guidance in the [Adopt Blazor Web App conventions](#adopt-blazor-web-app-conventions) section. 
+> This section focuses on the minimal changes required to convert a .NET 7 ASP.NET Core hosted Blazor WebAssembly app into a .NET 8 Blazor Web App. To adopt all of the new Blazor Web App conventions, follow the guidance in the [Adopt all Blazor Web App conventions](#adopt-all-blazor-web-app-conventions) section. 
 
 1. Follow the guidance in the first three sections of this article:
 
diff --git a/aspnetcore/release-notes/aspnetcore-8.0.md b/aspnetcore/release-notes/aspnetcore-8.0.md
index c2eab708d3e1..937e4471a027 100644
--- a/aspnetcore/release-notes/aspnetcore-8.0.md
+++ b/aspnetcore/release-notes/aspnetcore-8.0.md
@@ -332,9 +332,23 @@ Blazor.start({
 });
 ```
 
-#### New approach for the JavaScript client of a Blazor Server app
+#### New approach for the JavaScript client of server-side Blazor app
 
-The following example shows the ***new approach*** for assigning values that are double the default values in ASP.NET Core 8.0 or later:
+The following example shows the ***new approach*** for assigning values that are double the default values in ASP.NET Core 8.0 or later for Blazor Web Apps and Blazor Server.
+
+Blazor Web App:
+
+```javascript
+Blazor.start({
+  circuit: {
+    configureSignalR: function (builder) {
+      builder.withServerTimeout(60000).withKeepAliveInterval(30000);
+    }
+  }
+});
+```
+
+Blazor Server:
 
 ```javascript
 Blazor.start({
diff --git a/aspnetcore/tutorials/signalr-typescript-webpack.md b/aspnetcore/tutorials/signalr-typescript-webpack.md
index 744bbc609e59..db93ad769208 100644
--- a/aspnetcore/tutorials/signalr-typescript-webpack.md
+++ b/aspnetcore/tutorials/signalr-typescript-webpack.md
@@ -11,7 +11,7 @@ uid: tutorials/signalr-typescript-webpack
 ---
 # Tutorial: Get started with ASP.NET Core SignalR using TypeScript and Webpack
 
-By [Sébastien Sougnez](https://twitter.com/ssougnez)
+By [Sébastien Sougnez](https://twitter.com/s_sougnez)
 
 [!INCLUDE[](~/includes/not-latest-version.md)]