diff --git a/aspnetcore/blazor/components/integration.md b/aspnetcore/blazor/components/integration.md
index 274f02655c23..fa87c826bbd8 100644
--- a/aspnetcore/blazor/components/integration.md
+++ b/aspnetcore/blazor/components/integration.md
@@ -16,362 +16,521 @@ uid: blazor/components/integration
 
 This article explains Razor component integration scenarios for ASP.NET Core apps, including prerendering of Razor components on the server.
 
-> [!IMPORTANT]
-> This article is currently undergoing updates for .NET 8. Please check back periodically for new content or when .NET 8 is released.
+Razor components can be integrated into Razor Pages and MVC apps. When the page or view is rendered, components can be prerendered at the same time. Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
 
-<!-- UPDATE 8.0 HOLD
+Use the guidance in the following sections depending on the project's requirements:
 
-Razor components can be integrated into Razor Pages and MVC apps. When the page or view is rendered, components can be prerendered at the same time.
-  
-Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
+* For interactive components that aren't directly routable from user requests, see the [Use non-routable components in pages or views](#use-non-routable-components-in-pages-or-views) section. Follow this guidance when the app embeds components into existing pages and views with the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
+* For interactive components that are directly routable from user requests, see the [Use routable components](#use-routable-components) section. Follow this guidance when visitors should be able to make an HTTP request in their browser for a component with an [`@page`](xref:mvc/views/razor#page) directive.
 
-After [configuring the project](#configuration), use the guidance in the following sections depending on the project's requirements:
+## Use non-routable components in pages or views
 
-* For components that are directly routable from user requests. Follow this guidance when visitors should be able to make an HTTP request in their browser for a component with an [`@page`](xref:mvc/views/razor#page) directive.
-  * [Use routable components in a Razor Pages app](#use-routable-components-in-a-razor-pages-app)
-  * [Use routable components in an MVC app](#use-routable-components-in-an-mvc-app)
-* For components that aren't directly routable from user requests, see the [Render components from a page or view](#render-components-from-a-page-or-view) section. Follow this guidance when the app embeds components into existing pages and views with the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
+Use the following guidance to integrate Razor components into pages and views of an existing Razor Pages or MVC app with the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
 
-## Configuration
+When server prerendering is used and the page or view renders:
 
-Use the following guidance to integrate Razor components into pages and views of an existing Razor Pages or MVC app.
+* The component is prerendered with the page or view.
+* The initial component state used for prerendering is lost.
+* New component state is created when the SignalR connection is established.
 
-1. Add an imports file to the root folder of the project with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
+For more information on rendering modes, including non-interactive static component rendering, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>. To save the state of prerendered Razor components, see <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>.
 
-   `_Imports.razor`:
+Add a `Components` folder to the root folder of the project.
 
-   ```razor
-   @using System.Net.Http
-   @using Microsoft.AspNetCore.Authorization
-   @using Microsoft.AspNetCore.Components.Authorization
-   @using Microsoft.AspNetCore.Components.Forms
-   @using Microsoft.AspNetCore.Components.Routing
-   @using Microsoft.AspNetCore.Components.Web
-   @using Microsoft.AspNetCore.Components.Web.Virtualization
-   @using Microsoft.JSInterop
-   @using {APP NAMESPACE}
-   ```
+Add an imports file to the `Components` folder with the following content. Change the `{APP NAMESPACE}` placeholder to the namespace of the project.
 
-1. In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps or `Views/Shared/_Layout.cshtml` in MVC apps):
+`Components/_Imports.razor`:
 
-   * Add the following `<base>` tag and <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component Tag Helper to the `<head>` element:
+```razor
+@using System.Net.Http
+@using System.Net.Http.Json
+@using Microsoft.AspNetCore.Components.Forms
+@using Microsoft.AspNetCore.Components.Routing
+@using Microsoft.AspNetCore.Components.Web
+@using Microsoft.AspNetCore.Components.Web.Virtualization
+@using Microsoft.JSInterop
+@using {APP NAMESPACE}
+@using {APP NAMESPACE}.Components
+```
 
-     ```cshtml
-     <base href="~/" />
-     <component type="typeof(Microsoft.AspNetCore.Components.Web.HeadOutlet)" 
-         render-mode="ServerPrerendered" />
-     ```
+In the project's layout file (`Pages/Shared/_Layout.cshtml` in Razor Pages apps or `Views/Shared/_Layout.cshtml` in MVC apps):
 
-     The `href` value (the *app base path*) in the preceding example assumes that the app resides at the root URL path (`/`). If the app is a sub-application, follow the guidance in the *App base path* section of the <xref:blazor/host-and-deploy/index#app-base-path> article.
+* Add the following `<base>` tag and [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper) for a <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component to the `<head>` markup:
 
-     The <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component is used to render head (`<head>`) content for page titles (<xref:Microsoft.AspNetCore.Components.Web.PageTitle> component) and other head elements (<xref:Microsoft.AspNetCore.Components.Web.HeadContent> component) set by Razor components. For more information, see <xref:blazor/components/control-head-content>.
+  ```cshtml
+  <base href="~/" />
+  <component type="typeof(Microsoft.AspNetCore.Components.Web.HeadOutlet)" 
+      render-mode="ServerPrerendered" />
+  ```
 
-   * Add a `<script>` tag for the `blazor.server.js` script immediately before the `Scripts` render section (`@await RenderSectionAsync(...)`):
+  The `href` value (the *app base path*) in the preceding example assumes that the app resides at the root URL path (`/`). If the app is a sub-application, follow the guidance in the *App base path* section of the <xref:blazor/host-and-deploy/index#app-base-path> article.
 
-     ```html
-     <script src="_framework/blazor.server.js"></script>
-     ```
+  The <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component is used to render head (`<head>`) content for page titles (<xref:Microsoft.AspNetCore.Components.Web.PageTitle> component) and other head elements (<xref:Microsoft.AspNetCore.Components.Web.HeadContent> component) set by Razor components. For more information, see <xref:blazor/components/control-head-content>.
 
-     The framework adds the `blazor.server.js` script to the app. There's no need to manually add a `blazor.server.js` script file to the app.
+* Add a `<script>` tag for the `blazor.web.js` script immediately before the `Scripts` render section (`@await RenderSectionAsync(...)`):
 
-   > [!NOTE]
-   > Typically, the layout loads via a `_ViewStart.cshtml` file.
+  ```html
+  <script src="_framework/blazor.web.js"></script>
+  ```
 
-1. Register the Blazor Server services in `Program.cs` where services are registered:
+  There's no need to manually add a `blazor.web.js` script to the app because the Blazor framework adds the `blazor.web.js` script to the app.
 
-   ```csharp
-   builder.Services.AddServerSideBlazor();
-   ```
+> [!NOTE]
+> Typically, the layout loads via a `_ViewStart.cshtml` file.
 
-1. Add the Blazor Hub endpoint to the endpoints of `Program.cs` where routes are mapped. Place the following line after the call to `MapRazorPages` (Razor Pages) or `MapControllerRoute` (MVC):
+Where services are registered, add services for Razor components and services to support rendering interactive server components.
 
-   ```csharp
-   app.MapBlazorHub();
-   ```
+In the `Program` file before the line that builds the app (`builder.Build()`):
 
-1. Integrate components into any page or view. For example, add a `Counter` component to the project's `Shared` folder.
+```csharp
+builder.Services.AddRazorComponents()
+    .AddServerComponents();
+```
 
-   `Pages/Shared/Counter.razor` (Razor Pages) or `Views/Shared/Counter.razor` (MVC):
+<!-- UPDATE 8.0 RC2
 
-   ```razor
-   <h1>Counter</h1>
+```csharp
+builder.Services.AddRazorComponents()
+    .AddInteractiveServerComponents();
+```
 
-   <p>Current count: @currentCount</p>
+-->
 
-   <button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+For more information on adding support for server and WebAssembly components, see <xref:blazor/components/render-modes>.
 
-   @code {
-       private int currentCount = 0;
+<!-- UPDATE 8.0 Update API cross-link -->
 
-       private void IncrementCount()
-       {
-           currentCount++;
-       }
-   }
-   ```
+In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> to discover available components and specify the app's root component. By default, the app's root component is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
 
-   **Razor Pages**:
+```csharp
+app.MapRazorComponents<App>()
+    .AddServerRenderMode();
+```
 
-   In the project's `Index` page of a Razor Pages app, add the `Counter` component's namespace and embed the component into the page. When the `Index` page loads, the `Counter` component is prerendered in the page. In the following example, replace the `{APP NAMESPACE}` placeholder with the project's namespace.
+<!-- UPDATE 8.0 RC2
 
-   `Pages/Index.cshtml`:
+```csharp
+app.MapRazorComponents<App>()
+    .AddInteractiveServerRenderMode();
+```
 
-   ```cshtml
-   @page
-   @using {APP NAMESPACE}.Pages.Shared
-   @model IndexModel
-   @{
-       ViewData["Title"] = "Home page";
-   }
+-->
 
-   <component type="typeof(Counter)" render-mode="ServerPrerendered" />
-   ```
+> [!NOTE]
+> If the app hasn't already been updated to include Antiforgery Middleware, add the following line after <xref:Microsoft.AspNetCore.Builder.AuthorizationAppBuilderExtensions.UseAuthorization%2A> is called:
+>
+> ```csharp
+> app.UseAntiforgery();
+> ```
 
-   **MVC**:
+Integrate components into any page or view. For example, add an `EmbeddedCounter` component to the project's `Components` folder.
 
-   In the project's `Index` view of an MVC app, add the `Counter` component's namespace and embed the component into the view. When the `Index` view loads, the `Counter` component is prerendered in the page. In the following example, replace the `{APP NAMESPACE}` placeholder with the project's namespace.
+`Components/EmbeddedCounter.razor`:
 
-   `Views/Home/Index.cshtml`:
+```razor
+<h1>Embedded Counter</h1>
 
-   ```cshtml
-   @using {APP NAMESPACE}.Views.Shared
-   @{
-       ViewData["Title"] = "Home Page";
-   }
+<p>Current count: @currentCount</p>
 
-   <component type="typeof(Counter)" render-mode="ServerPrerendered" />
-   ```
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
 
-For more information, see the [Render components from a page or view](#render-components-from-a-page-or-view) section.
+@code {
+    private int currentCount = 0;
 
-## Use routable components in a Razor Pages app
+    private void IncrementCount()
+    {
+        currentCount++;
+    }
+}
+```
 
-*This section pertains to adding components that are directly routable from user requests.*
+**Razor Pages**:
 
-To support routable Razor components in Razor Pages apps:
+In the project's `Index` page of a Razor Pages app, add the `EmbeddedCounter` component's namespace and embed the component into the page. When the `Index` page loads, the `EmbeddedCounter` component is prerendered in the page. In the following example, replace the `{APP NAMESPACE}` placeholder with the project's namespace.
 
-1. Follow the guidance in the [Configuration](#configuration) section.
+`Pages/Index.cshtml`:
 
-1. Add an `App` component to the project root with the following content.
+```cshtml
+@page
+@using {APP NAMESPACE}.Components
+@model IndexModel
+@{
+    ViewData["Title"] = "Home page";
+}
 
-   `App.razor`:
+<component type="typeof(EmbeddedCounter)" render-mode="ServerPrerendered" />
+```
 
-   ```razor
-   @using Microsoft.AspNetCore.Components.Routing
+**MVC**:
 
-   <Router AppAssembly="@typeof(App).Assembly">
-       <Found Context="routeData">
-           <RouteView RouteData="@routeData" />
-       </Found>
-       <NotFound>
-           <PageTitle>Not found</PageTitle>
-           <p role="alert">Sorry, there's nothing at this address.</p>
-       </NotFound>
-   </Router>
-   ```
+In the project's `Index` view of an MVC app, add the `EmbeddedCounter` component's namespace and embed the component into the view. When the `Index` view loads, the `EmbeddedCounter` component is prerendered in the page. In the following example, replace the `{APP NAMESPACE}` placeholder with the project's namespace.
 
-1. Add a `_Host` page to the project with the following content. Replace the `{APP NAMESPACE}` placeholder with the app's namespace.
+`Views/Home/Index.cshtml`:
 
-   `Pages/_Host.cshtml`:
+```cshtml
+@using {APP NAMESPACE}.Components
+@{
+    ViewData["Title"] = "Home Page";
+}
 
-   ```cshtml
-   @page
-   @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+<component type="typeof(EmbeddedCounter)" render-mode="ServerPrerendered" />
+```
 
-   <component type="typeof(App)" render-mode="ServerPrerendered" />
-   ```
+## Use routable components
 
-   > [!NOTE]
-   > The preceding example assumes that the <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component and Blazor script (`_framework/blazor.server.js`) are rendered by the app's layout. For more information, see the [Configuration](#configuration) section.
-  
-   <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configures whether the `App` component:
+Use the following guidance to integrate routable Razor components into an existing Razor Pages or MVC app.
 
-   * Is prerendered into the page.
-   * Is rendered as static HTML on the page or if it includes the necessary information to bootstrap a Blazor app from the user agent.
+The guidance in this section assumes:
 
-   For more information on the Component Tag Helper, including passing parameters and <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configuration, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>.
+* The title of the app is `Blazor Sample`.
+* The namespace of the app is `BlazorSample`.
 
-1. In the `Program.cs` endpoints, add a low-priority route for the `_Host` page as the last endpoint:
+To support routable Razor components:
 
-   ```csharp
-   app.MapFallbackToPage("/_Host");
-   ```
+Add a `Components` folder to the root folder of the project.
 
-1. Add routable components to the project. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
+Add an imports file to the `Components` folder with the following content.
 
-   `Pages/RoutableCounter.razor`:
+`Components/_Imports.razor`:
 
-   ```razor
-   @page "/routable-counter"
+```razor
+@using System.Net.Http
+@using System.Net.Http.Json
+@using Microsoft.AspNetCore.Components.Forms
+@using Microsoft.AspNetCore.Components.Routing
+@using Microsoft.AspNetCore.Components.Web
+@using Microsoft.AspNetCore.Components.Web.Virtualization
+@using Microsoft.JSInterop
+@using {APP NAMESPACE}
+@using {APP NAMESPACE}.Components
+```
 
-   <PageTitle>Routable Counter</PageTitle>
+Change the `{APP NAMESPACE}` placeholder to the namespace of the project. For example:
 
-   <h1>Routable Counter</h1>
+```razor
+@using BlazorSample
+@using BlazorSample.Components
+```
 
-   <p>Current count: @currentCount</p>
+Add a `Layout` folder to the `Components` folder.
 
-   <button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+Add a footer component and stylesheet to the `Layout` folder.
 
-   @code {
-       private int currentCount = 0;
+`Components/Layout/Footer.razor`:
 
-       private void IncrementCount()
-       {
-           currentCount++;
-       }
-   }
-   ```
+```razor
+<footer class="border-top footer text-muted">
+    <div class="container">
+        &copy; 2023 - {APP TITLE} - <a href="/privacy">Privacy</a>
+    </div>
+</footer>
+```
 
-1. Run the project and navigate to the routable `RoutableCounter` component at `/routable-counter`.
+In the preceding markup, set the `{APP TITLE}` placeholder to the title of the app. For example:
 
-For more information on namespaces, see the [Component namespaces](#component-namespaces) section.
+```html
+&copy; 2023 - Blazor Sample - <a href="/privacy">Privacy</a>
+```
+
+`Components/Layout/Footer.razor.css`:
+
+```css
+.footer {
+position: absolute;
+bottom: 0;
+width: 100%;
+white-space: nowrap;
+line-height: 60px;
+}
+```
 
-## Use routable components in an MVC app
+Add a navigation menu component to the `Layout` folder.
+
+`Components/Layout/NavMenu.razor`:
+
+```razor
+<nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
+<div class="container">
+    <a class="navbar-brand" href="/">{APP TITLE}</a>
+    <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
+        <span class="navbar-toggler-icon"></span>
+    </button>
+    <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
+        <ul class="navbar-nav flex-grow-1">
+            <li class="nav-item">
+                <a class="nav-link text-dark" href="/">Home</a>
+            </li>
+            <li class="nav-item">
+                <a class="nav-link text-dark" href="/privacy">Privacy</a>
+            </li>
+            <li class="nav-item">
+                <a class="nav-link text-dark" href="/counter">Counter</a>
+            </li>
+        </ul>
+    </div>
+</div>
+</nav>
+```
 
-*This section pertains to adding components that are directly routable from user requests.*
+In the preceding markup, set the `{APP TITLE}` placeholder to the title of the app. For example:
 
-To support routable Razor components in MVC apps:
+```html
+<a class="navbar-brand" href="/">Blazor Sample</a>
+```
 
-1. Follow the guidance in the [Configuration](#configuration) section.
+`Components/Layout/NavMenu.razor.css`:
 
-1. Add an `App` component to the project root with the following content.
+```css
+a.navbar-brand {
+    white-space: normal;
+    text-align: center;
+    word-break: break-all;
+}
 
-   `App.razor`:
+a {
+    color: #0077cc;
+}
 
-   ```razor
-   @using Microsoft.AspNetCore.Components.Routing
+.btn-primary {
+    color: #fff;
+    background-color: #1b6ec2;
+    border-color: #1861ac;
+}
 
-   <Router AppAssembly="@typeof(App).Assembly">
-       <Found Context="routeData">
-           <RouteView RouteData="@routeData" />
-       </Found>
-       <NotFound>
-           <PageTitle>Not found</PageTitle>
-           <p role="alert">Sorry, there's nothing at this address.</p>
-       </NotFound>
-   </Router>
-   ```
+.nav-pills .nav-link.active, .nav-pills .show > .nav-link {
+    color: #fff;
+    background-color: #1b6ec2;
+    border-color: #1861ac;
+}
 
-1. Add a `_Host` view to the project with the following content. Replace the `{APP NAMESPACE}` placeholder with the app's namespace.
+.border-top {
+    border-top: 1px solid #e5e5e5;
+}
 
-   `Views/Home/_Host.cshtml`:
+.border-bottom {
+    border-bottom: 1px solid #e5e5e5;
+}
 
-   ```cshtml
-   @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+.box-shadow {
+    box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
+}
 
-   <component type="typeof(App)" render-mode="ServerPrerendered" />
+button.accept-policy {
+    font-size: 1rem;
+    line-height: inherit;
+}
    ```
 
-   > [!NOTE]
-   > The preceding example assumes that the <xref:Microsoft.AspNetCore.Components.Web.HeadOutlet> component and Blazor script (`_framework/blazor.server.js`) are rendered by the app's layout. For more information, see the [Configuration](#configuration) section.
+Add a main layout component and stylesheet to the `Layout` folder.
 
-   <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configures whether the `App` component:
+`Components/Layout/MainLayout.razor`:
 
-   * Is prerendered into the page.
-   * Is rendered as static HTML on the page or if it includes the necessary information to bootstrap a Blazor app from the user agent.
+```razor
+@inherits LayoutComponentBase
 
-   For more information on the Component Tag Helper, including passing parameters and <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configuration, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>.
+<header>
+    <NavMenu />
+</header>
 
-1. Add an action to the Home controller.
+<div class="container">
+    <main role="main" class="pb-3">
+        @Body
+    </main>
+</div>
 
-   `Controllers/HomeController.cs`:
+<Footer />
 
-   ```csharp
-   public IActionResult Blazor()
-   {
-      return View("_Host");
-   }
-   ```
+<div id="blazor-error-ui">
+    An unhandled error has occurred.
+    <a href="" class="reload">Reload</a>
+    <a class="dismiss">🗙</a>
+</div>
+```
 
-1. In the `Program.cs` endpoints, add a low-priority route for the controller action that returns the `_Host` view:
+`Components/Layout/MainLayout.razor.css`:
+
+```css
+#blazor-error-ui {
+    background: lightyellow;
+    bottom: 0;
+    box-shadow: 0 -1px 2px rgba(0, 0, 0, 0.2);
+    display: none;
+    left: 0;
+    padding: 0.6rem 1.25rem 0.7rem 1.25rem;
+    position: fixed;
+    width: 100%;
+    z-index: 1000;
+}
 
-   ```csharp
-   app.MapFallbackToController("Blazor", "Home");
-   ```
+    #blazor-error-ui .dismiss {
+        cursor: pointer;
+        position: absolute;
+        right: 0.75rem;
+        top: 0.5rem;
+    }
+```
 
-1. Create a `Pages` folder in the MVC app and add routable components. The following example is a `RoutableCounter` component based on the `Counter` component in the Blazor project templates.
+Add a `Routes` component to the `Components` folder with the following content.
 
-   `Pages/RoutableCounter.razor`:
+`Components/Routes.razor`:
 
-   ```razor
-   @page "/routable-counter"
+```razor
+<Router AppAssembly="@typeof(Program).Assembly">
+    <Found Context="routeData">
+        <RouteView RouteData="@routeData" DefaultLayout="@typeof(Layout.MainLayout)" />
+        <FocusOnNavigate RouteData="@routeData" Selector="h1" />
+    </Found>
+</Router>
+```
 
-   <PageTitle>Routable Counter</PageTitle>
+Add an `App` component to the `Components` folder with the following content.
+
+`Components/App.razor`:
+
+```razor
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{APP TITLE}</title>
+    <link rel="stylesheet" href="/lib/bootstrap/dist/css/bootstrap.min.css" />
+    <link rel="stylesheet" href="/css/site.css" />
+    <link rel="stylesheet" href="/{APP NAMESPACE}.styles.css" />
+    <HeadOutlet />
+</head>
+<body>
+    <Routes />
+    <script src="/lib/jquery/dist/jquery.min.js"></script>
+    <script src="/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
+    <script src="/js/site.js"></script>
+    <script src="_framework/blazor.web.js"></script>
+</body>
+</html>
+```
 
-   <h1>Routable Counter</h1>
+In the preceding code update the app title and stylesheet file name:
 
-   <p>Current count: @currentCount</p>
+* For the `{APP TITLE}` placeholder in the `<title>` element, set the app's title. For example:
 
-   <button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+  ```html
+  <title>Blazor Sample</title>
+  ```
 
-   @code {
-       private int currentCount = 0;
+* For the `{APP NAMESPACE}` placeholder in the stylesheet `<link>` element, set the app's namespace. For example:
 
-       private void IncrementCount()
-       {
-           currentCount++;
-       }
-   }
-   ```
+  ```html
+  <link rel="stylesheet" href="/BlazorSample.styles.css" />
+  ```
 
-1. Run the project and navigate to the routable `RoutableCounter` component at `/routable-counter`.
+Where services are registered, add services for Razor components and services to support rendering interactive server components.
 
-For more information on namespaces, see the [Component namespaces](#component-namespaces) section.
+In the `Program` file before the line that builds the app (`builder.Build()`):
 
-## Render components from a page or view
+```csharp
+builder.Services.AddRazorComponents()
+    .AddServerComponents();
+```
 
-*This section pertains to adding components to pages or views, where the components aren't directly routable from user requests.*
+<!-- UPDATE 8.0 RC2
 
-To render a component from a page or view, use the [Component Tag Helper](xref:mvc/views/tag-helpers/builtin-th/component-tag-helper).
+```csharp
+builder.Services.AddRazorComponents()
+    .AddInteractiveServerComponents();
+```
 
-### Render stateful interactive components
+-->
 
-Stateful interactive components can be added to a Razor page or view.
+For more information on adding support for server and WebAssembly components, see <xref:blazor/components/render-modes>.
 
-When the page or view renders:
+<!-- UPDATE 8.0 Update API cross-link -->
 
-* The component is prerendered with the page or view.
-* The initial component state used for prerendering is lost.
-* New component state is created when the SignalR connection is established.
+In the `Program` file immediately after the call to map Razor Pages (<xref:Microsoft.AspNetCore.Builder.RazorPagesEndpointRouteBuilderExtensions.MapRazorPages%2A>), call <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointRouteBuilderExtensions.MapRazorComponents%2A> to discover available components and specify the app's root component. By default, the app's root component is the `App` component (`App.razor`). Chain a call to `AddInteractiveServerRenderMode` <!-- <xref:Microsoft.AspNetCore.Builder.RazorComponentsEndpointConventionBuilder.AddInteractiveServerRenderMode%2A> --> to configure the Server render mode for the app:
+
+```csharp
+app.MapRazorComponents<App>()
+    .AddServerRenderMode();
+```
 
-The following Razor page renders a `Counter` component:
+<!-- UPDATE 8.0 RC2
 
-```cshtml
-<h1>Razor Page</h1>
+```csharp
+app.MapRazorComponents<App>()
+    .AddInteractiveServerRenderMode();
+```
+
+-->
+
+> [!NOTE]
+> If the app hasn't already been updated to include Antiforgery Middleware, add the following line after <xref:Microsoft.AspNetCore.Builder.AuthorizationAppBuilderExtensions.UseAuthorization%2A> is called:
+>
+> ```csharp
+> app.UseAntiforgery();
+> ```
+
+Create a `Pages` folder in the `Components` folder for routable components. The following example is a `Counter` component based on the `Counter` component in the Blazor project templates.
+
+`Components/Pages/Counter.razor`:
+
+```razor
+@page "/counter"
+@attribute [RenderModeServer]
+
+<PageTitle>Counter</PageTitle>
+
+<h1>Counter</h1>
 
-<component type="typeof(Counter)" render-mode="ServerPrerendered" 
-    param-InitialValue="InitialValue" />
+<p>Current count: @currentCount</p>
 
-@functions {
-    [BindProperty(SupportsGet=true)]
-    public int InitialValue { get; set; }
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+
+@code {
+    private int currentCount = 0;
+
+    private void IncrementCount()
+    {
+        currentCount++;
+    }
 }
 ```
 
-For more information, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>.
+<!-- UPDATE 8.0 RC2
 
-### Render noninteractive components
+@attribute [RenderModeInteractiveServer]
 
-In the following Razor page, the `Counter` component is statically rendered with an initial value that's specified using a form. Since the component is statically rendered, the component isn't interactive:
+-->
 
-```cshtml
-<h1>Razor Page</h1>
+Run the project and navigate to the routable `Counter` component at `/counter`.
+
+For more information on namespaces, see the [Component namespaces](#component-namespaces) section.
+
+## Return a `RazorComponentResult` from an MVC controller action
 
-<form>
-    <input type="number" asp-for="InitialValue" />
-    <button type="submit">Set initial value</button>
-</form>
+An MVC controller action can return a component with `RazorComponentResult`.
 
-<component type="typeof(Counter)" render-mode="Static" 
-    param-InitialValue="InitialValue" />
+`Components/Welcome.razor`:
 
-@functions {
-    [BindProperty(SupportsGet=true)]
-    public int InitialValue { get; set; }
+```razor
+<PageTitle>Welcome!</PageTitle>
+
+<h1>Welcome!</h1>
+
+<p>@Message</p>
+
+@code {
+    [Parameter]
+    public string? Message { get; set; }
 }
 ```
 
-For more information, see <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>.
+In a controller:
+
+```csharp
+public IResult GetWelcomeComponent()
+{
+    return new RazorComponentResult<Welcome>(new { Message = "Hello, world!" });
+}
+```
 
 ## Component namespaces
 
@@ -384,30 +543,17 @@ When using a custom folder to hold the project's Razor components, add the names
 @using {APP NAMESPACE}.Components
 ```
 
-The `_ViewImports.cshtml` file is located in the `Pages` folder of a Razor Pages app or the `Views` folder of an MVC app.
-
-For more information, see <xref:blazor/components/index#class-name-and-namespace>.
-
-<!-- UPDATE 8.0 This content will cross-link the section 
-                of the same name in the Prerendering article. 
-
-## Persist prerendered state
-
-## Prerendered state size and SignalR message size limit
-
-A large prerendered state size may exceed the SignalR circuit message size limit, which results in the following:
+For example:
 
-* The SignalR circuit fails to initialize with an error on the client: :::no-loc text="Circuit host not initialized.":::
-* The reconnection dialog on the client appears when the circuit fails. Recovery isn't possible.
-
-To resolve the problem, use ***either*** of the following approaches:
+```cshtml
+@using BlazorSample.Components
+```
 
-* Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+The `_ViewImports.cshtml` file is located in the `Pages` folder of a Razor Pages app or the `Views` folder of an MVC app.
 
+For more information, see <xref:blazor/components/index#class-name-and-namespace>.
 
 ## Additional resources
 
 <xref:blazor/components/prerender>
 
--->
diff --git a/aspnetcore/blazor/components/prerendering-and-integration.md b/aspnetcore/blazor/components/prerendering-and-integration.md
index edac61c0eb92..0eeb6c978156 100644
--- a/aspnetcore/blazor/components/prerendering-and-integration.md
+++ b/aspnetcore/blazor/components/prerendering-and-integration.md
@@ -952,7 +952,7 @@ A large prerendered state size may exceed the SignalR circuit message size limit
 To resolve the problem, use ***either*** of the following approaches:
 
 * Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
 
 ## Additional Blazor Server resources
 
@@ -1895,7 +1895,7 @@ A large prerendered state size may exceed the SignalR circuit message size limit
 To resolve the problem, use ***either*** of the following approaches:
 
 * Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
 
 ## Additional Blazor Server resources
 
@@ -2601,7 +2601,7 @@ A large prerendered state size may exceed the SignalR circuit message size limit
 To resolve the problem, use ***either*** of the following approaches:
 
 * Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
 
 ## Additional Blazor Server resources
 
@@ -3041,7 +3041,7 @@ A large prerendered state size may exceed the SignalR circuit message size limit
 To resolve the problem, use ***either*** of the following approaches:
 
 * Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
 
 ## Additional Blazor Server resources
 
diff --git a/aspnetcore/blazor/components/prerendering.md b/aspnetcore/blazor/components/prerendering.md
index ca8d843968e5..bd5bf566d449 100644
--- a/aspnetcore/blazor/components/prerendering.md
+++ b/aspnetcore/blazor/components/prerendering.md
@@ -14,110 +14,162 @@ uid: blazor/components/prerender
 [!INCLUDE[](~/includes/not-latest-version.md)]
 -->
 
-This article explains Razor component prerendering scenarios for server-side Blazor apps.
+<!--
+    NOTE: The console output block quotes in this topic use a double-space 
+    at the ends of lines to generate a bare return in block quote output.
+-->
+
+This article explains Razor component prerendering scenarios for server-rendered components in Blazor Web Apps.
   
 Prerendering can improve [Search Engine Optimization (SEO)](https://developer.mozilla.org/docs/Glossary/SEO) by rendering content for the initial HTTP response that search engines can use to calculate page rank.
 
-<!-- UPDATE 8.0 Remove IMPORTANT notice -->
+## Persist prerendered state
 
-> [!IMPORTANT]
-> This article is currently undergoing updates for .NET 8. Please check back periodically for new content or when .NET 8 is released.
+Without persisting prerendered state, state used during prerendering is lost and must be recreated when the app is fully loaded. If any state is created asynchronously, the UI may flicker as the prerendered UI is replaced when the component is rerendered.
 
-## Persist prerendered state
+Consider the following `PrerenderedCounter1` counter component. The component sets an initial random counter value during prerendering in `OnInitialized`. After the SignalR connection to the client is established, the component rerenders, and the initial count value is replaced when `OnInitialized` executes a second time.
 
-> [!IMPORTANT]
-> This section is currently undergoing updates for .NET 8.
+`Components/Pages/PrerenderedCounter1.razor`:
 
-Without persisting prerendered state, state used during prerendering is lost and must be recreated when the app is fully loaded. If any state is setup asynchronously, the UI may flicker as the prerendered UI is replaced with temporary placeholders and then fully rendered again.
+```razor
+@page "/prerendered-counter-1"
+@attribute [RenderModeServer]
+@inject ILogger<PrerenderedCounter1> Logger
 
-<!-- UPDATE 8.0>
+<PageTitle>Prerendered Counter 1</PageTitle>
 
-UPDATE 8.0 WORK IN PROGRESS ...
+<h1>Prerendered Counter 1</h1>
 
-To solve these problems, Blazor supports persisting state in a prerendered page using the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper). Add the Tag Helper's tag, `<persist-component-state />`, inside the closing `</body>` tag.
+<p role="status">Current count: @currentCount</p>
 
-`Pages/_Host.cshtml`:
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
 
-```cshtml
-<body>
-    ...
+@code {
+    private int currentCount;
+    private Random r = new Random();
 
-    <persist-component-state />
-</body>
+    protected override void OnInitialized()
+    {
+        currentCount = r.Next(100);
+        Logger.LogInformation("currentCount set to {Count}", currentCount);
+    }
+
+    private void IncrementCount()
+    {
+        currentCount++;
+    }
+}
 ```
 
-Decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes.
+<!-- UPDATE 8.0 RC2
 
-The following example is an updated version of the `FetchData` component in a hosted Blazor WebAssembly app based on the Blazor project template. The `WeatherForecastPreserveState` component persists weather forecast state during prerendering and then retrieves the state to initialize the component. The [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper) persists the component state after all component invocations.
+@attribute [RenderModeInteractiveServer]
 
-`Pages/WeatherForecastPreserveState.razor`:
+-->
+
+Run the app and inspect logging from the component:
+
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter1[0]":::  
+> :::no-loc text="      currentCount set to 41":::  
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter1[0]":::  
+> :::no-loc text="      currentCount set to 92":::
+
+The first logged count occurs during prerendering. The count is set again after prerendering when the component is rerendered. There's also a flicker in the UI when the count updates from 41 to 92.
+
+To retain the initial value of the counter during prerendering, Blazor supports persisting state in a prerendered page using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service (and for components embedded into pages or views of Razor Pages or MVC apps, the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper)).
+
+To preserve prerendered state, decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the app resumes.
+
+The following example demonstrates the general pattern:
+
+* The `{TYPE}` placeholder represents the type of data to persist.
+* The `{TOKEN}` placeholder is a state identifier string.
 
 ```razor
-@page "/weather-forecast-preserve-state"
 @implements IDisposable
-@using BlazorSample.Shared
-@inject IWeatherForecastService WeatherForecastService
 @inject PersistentComponentState ApplicationState
 
-<PageTitle>Weather Forecast</PageTitle>
+...
 
-<h1>Weather forecast</h1>
+@code {
+    private {TYPE} data;
+    private PersistingComponentStateSubscription persistingSubscription;
 
-<p>This component demonstrates fetching data from the server.</p>
+    protected override async Task OnInitializedAsync()
+    {
+        persistingSubscription = 
+            ApplicationState.RegisterOnPersisting(PersistData);
 
-@if (forecasts == null)
-{
-    <p><em>Loading...</em></p>
-}
-else
-{
-    <table class="table">
-        <thead>
-            <tr>
-                <th>Date</th>
-                <th>Temp. (C)</th>
-                <th>Temp. (F)</th>
-                <th>Summary</th>
-            </tr>
-        </thead>
-        <tbody>
-            @foreach (var forecast in forecasts)
-            {
-                <tr>
-                    <td>@forecast.Date.ToShortDateString()</td>
-                    <td>@forecast.TemperatureC</td>
-                    <td>@forecast.TemperatureF</td>
-                    <td>@forecast.Summary</td>
-                </tr>
-            }
-        </tbody>
-    </table>
+        if (!ApplicationState.TryTakeFromJson<{TYPE}>(
+            "{TOKEN}", out var restored))
+        {
+            data = await ...;
+        }
+        else
+        {
+            data = restored!;
+        }
+    }
+
+    private Task PersistData()
+    {
+        ApplicationState.PersistAsJson("{TOKEN}", data);
+
+        return Task.CompletedTask;
+    }
+
+    void IDisposable.Dispose()
+    {
+        persistingSubscription.Dispose();
+    }
 }
+```
+
+The following counter component example persists counter state during prerendering and retrieves the state to initialize the component. 
+
+`Components/Pages/PrerenderedCounter2.razor`:
+
+```razor
+@page "/prerendered-counter-2"
+@attribute [RenderModeServer]
+@implements IDisposable
+@inject ILogger<PrerenderedCounter2> Logger
+@inject PersistentComponentState ApplicationState
+
+<PageTitle>Prerendered Counter 2</PageTitle>
+
+<h1>Prerendered Counter 2</h1>
+
+<p role="status">Current count: @currentCount</p>
+
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
 
 @code {
-    private WeatherForecast[] forecasts = Array.Empty<WeatherForecast>();
+    private int currentCount;
+    private Random r = new Random();
     private PersistingComponentStateSubscription persistingSubscription;
 
-    protected override async Task OnInitializedAsync()
+    protected override void OnInitialized()
     {
-        persistingSubscription = 
-            ApplicationState.RegisterOnPersisting(PersistForecasts);
+        persistingSubscription =
+            ApplicationState.RegisterOnPersisting(PersistCount);
 
-        if (!ApplicationState.TryTakeFromJson<WeatherForecast[]>(
-            "fetchdata", out var restored))
+        if (!ApplicationState.TryTakeFromJson<int>(
+            "count", out var restoredCount))
         {
-            forecasts = 
-                await WeatherForecastService.GetForecastAsync(DateOnly.FromDateTime(DateTime.Now));
+            currentCount = r.Next(100);
+            Logger.LogInformation("currentCount set to {Count}", currentCount);
         }
         else
         {
-            forecasts = restored!;
+            currentCount = restoredCount!;
+            Logger.LogInformation("currentCount restored to {Count}", currentCount);
         }
     }
 
-    private Task PersistForecasts()
+    private Task PersistCount()
     {
-        ApplicationState.PersistAsJson("fetchdata", forecasts);
+        ApplicationState.PersistAsJson("count", currentCount);
 
         return Task.CompletedTask;
     }
@@ -126,35 +178,63 @@ else
     {
         persistingSubscription.Dispose();
     }
+
+    private void IncrementCount()
+    {
+        currentCount++;
+    }
 }
 ```
 
-By initializing components with the same state used during prerendering, any expensive initialization steps are only executed once. The rendered UI also matches the prerendered UI, so no flicker occurs in the browser.
+<!-- UPDATE 8.0 RC2
+
+@attribute [RenderModeInteractiveServer]
 
 -->
 
-## Prerendered state size and SignalR message size limit
+When the component executes, `currentCount` is only set once during prerendering. The value is restored when the component is rerendered:
 
-A large prerendered state size may exceed the SignalR circuit message size limit, which results in the following:
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter2[0]":::  
+> :::no-loc text="      currentCount set to 96":::  
+> :::no-loc text="info: BlazorSample.Components.Pages.PrerenderedCounter2[0]":::  
+> :::no-loc text="      currentCount restored to 96":::
 
-* The SignalR circuit fails to initialize with an error on the client: :::no-loc text="Circuit host not initialized.":::
-* The reconnection dialog on the client appears when the circuit fails. Recovery isn't possible.
+By initializing components with the same state used during prerendering, any expensive initialization steps are only executed once. The rendered UI also matches the prerendered UI, so no flicker occurs in the browser.
 
-To resolve the problem, use ***either*** of the following approaches:
+For components embedded into a page or view of a Razor Pages or MVC app, you must add the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper) with the `<persist-component-state />` HTML tag inside the closing `</body>` tag of the app's layout. **This is only required for Razor Pages and MVC apps.** For more information, see <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>.
 
-* Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+`Pages/Shared/_Layout.cshtml`:
 
-## Additional resources
+```cshtml
+<body>
+    ...
+
+    <persist-component-state />
+</body>
+```
 
-* [State management: Handle prerendering](xref:blazor/state-management#handle-prerendering)
-* Razor component lifecycle subjects that pertain to prerendering
-  * [Component initialization (`OnInitialized{Async}`)](xref:blazor/components/lifecycle#component-initialization-oninitializedasync)
-  * [After component render (`OnAfterRender{Async}`)](xref:blazor/components/lifecycle#after-component-render-onafterrenderasync)
-  * [Stateful reconnection after prerendering](xref:blazor/components/lifecycle#stateful-reconnection-after-prerendering)
-  * [Prerendering with JavaScript interop](xref:blazor/components/lifecycle#prerendering-with-javascript-interop)
-* [Authentication and authorization: General aspects](xref:blazor/security/index#aspnet-core-blazor-authentication-and-authorization)
-* [Handle Errors: Prerendering](xref:blazor/fundamentals/handle-errors#prerendering)
-* [Host and deploy: Blazor Server](xref:blazor/host-and-deploy/server)
-* [Threat mitigation: Cross-site scripting (XSS)](xref:blazor/security/server/threat-mitigation#cross-site-scripting-xss)
-* <xref:Microsoft.AspNetCore.Components.Routing.Router.OnNavigateAsync> is executed *twice* when prerendering: [Handle asynchronous navigation events with `OnNavigateAsync`](xref:blazor/fundamentals/routing#handle-asynchronous-navigation-events-with-onnavigateasync)
+## Prerendering guidance
+
+Prerendering guidance is organized in the Blazor documentation by subject matter. The following links cover all of the prerendering guidance throughout the documentation set by subject:
+
+* Fundamentals
+  * <xref:Microsoft.AspNetCore.Components.Routing.Router.OnNavigateAsync> is executed *twice* when prerendering: [Handle asynchronous navigation events with `OnNavigateAsync`](xref:blazor/fundamentals/routing#handle-asynchronous-navigation-events-with-onnavigateasync)
+  * [Startup: Control headers in C# code](xref:blazor/fundamentals/startup#control-headers-in-c-code)
+  * [Handle Errors: Prerendering](xref:blazor/fundamentals/handle-errors#prerendering)
+  * [SignalR: Prerendered state size and SignalR message size limit](xref:blazor/fundamentals/signalr#prerendered-state-size-and-signalr-message-size-limit)
+* [Render modes: Prerendering](xref:blazor/components/render-modes#prerendering)
+* Components
+  * [Control `<head>` content during prerendering](xref:blazor/components/control-head-content#control-head-content-during-prerendering)
+  * Razor component lifecycle subjects that pertain to prerendering
+    * [Component initialization (`OnInitialized{Async}`)](xref:blazor/components/lifecycle#component-initialization-oninitializedasync)
+    * [After component render (`OnAfterRender{Async}`)](xref:blazor/components/lifecycle#after-component-render-onafterrenderasync)
+    * [Stateful reconnection after prerendering](xref:blazor/components/lifecycle#stateful-reconnection-after-prerendering)
+    * [Prerendering with JavaScript interop](xref:blazor/components/lifecycle#prerendering-with-javascript-interop): This section also appears in the two JS interop articles on calling JavaScript from .NET and calling .NET from JavaScript.
+  * [QuickGrid component sample app](xref:blazor/components/quickgrid#sample-app): The [**QuickGrid for Blazor** sample app](https://aspnet.github.io/quickgridsamples/) is hosted on GitHub Pages. The site loads fast thanks to static prerendering using the community-maintained [`BlazorWasmPrerendering.Build` GitHub project](https://github.com/jsakamoto/BlazorWasmPreRendering.Build).
+  * [Prerendering when integrating components into Razor Pages and MVC apps](xref:blazor/components/integration)
+* Authentication and authorization
+  * [Server-side threat mitigation: Cross-site scripting (XSS)](xref:blazor/security/server/threat-mitigation#cross-site-scripting-xss)
+  * [Unauthorized content display while prerendering with a custom `AuthenticationStateProvider`](xref:blazor/security/server/index#unauthorized-content-display-while-prerendering-with-a-custom-authenticationstateprovider)
+  * [WebAssembly prerendering support](xref:blazor/security/webassembly/index#prerendering-support)
+<!-- UPDATE 8.0 HOLD LINK FOR WORK AT DESTINATION * [Blazor WebAssembly rendered component authentication with prerendering](xref:blazor/security/webassembly/additional-scenarios#prerendering-with-authentication) -->
+* [State management: Handle prerendering](xref:blazor/state-management#handle-prerendering): Besides the *Handle prerendering* section, several of the article's other sections include remarks on prerendering.
diff --git a/aspnetcore/blazor/file-downloads.md b/aspnetcore/blazor/file-downloads.md
index cb21c0b48714..8191e6b8c0d8 100644
--- a/aspnetcore/blazor/file-downloads.md
+++ b/aspnetcore/blazor/file-downloads.md
@@ -30,7 +30,7 @@ When downloading files from a different origin than the app, Cross-Origin Resour
 
 ## Security considerations
 
-Use caution when providing users with the ability to download files from a server. Attackers may execute [denial of service (DOS)](/windows-hardware/drivers/ifs/denial-of-service) attacks, [API exploitation attacks](https://developer.mozilla.org/docs/Web/HTML/Element/a#security_and_privacy), or attempt to compromise networks and servers in other ways.
+Use caution when providing users with the ability to download files from a server. Attackers may execute [Denial of Service (DoS)](/windows-hardware/drivers/ifs/denial-of-service) attacks, [API exploitation attacks](https://developer.mozilla.org/docs/Web/HTML/Element/a#security_and_privacy), or attempt to compromise networks and servers in other ways.
 
 Security steps that reduce the likelihood of a successful attack are:
 
diff --git a/aspnetcore/blazor/fundamentals/signalr.md b/aspnetcore/blazor/fundamentals/signalr.md
index afd6434d6193..5d860760117d 100644
--- a/aspnetcore/blazor/fundamentals/signalr.md
+++ b/aspnetcore/blazor/fundamentals/signalr.md
@@ -105,6 +105,18 @@ If prerendering is configured, prerendering occurs before the client connection
 
 :::moniker-end
 
+## Prerendered state size and SignalR message size limit
+
+A large prerendered state size may exceed the SignalR circuit message size limit, which results in the following:
+
+* The SignalR circuit fails to initialize with an error on the client: :::no-loc text="Circuit host not initialized.":::
+* The reconnection dialog on the client appears when the circuit fails. Recovery isn't possible.
+
+To resolve the problem, use ***either*** of the following approaches:
+
+* Reduce the amount of data that you are putting into the prerendered state.
+* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#server-side-circuit-handler-options). ***WARNING***: Increasing the limit may increase the risk of Denial of Service (DoS) attacks.
+
 ## Additional client-side resources
 
 * [Secure a SignalR hub](xref:blazor/security/webassembly/index#secure-a-signalr-hub)
@@ -259,7 +271,7 @@ services.AddServerSideBlazor().AddHubOptions(options =>
 :::moniker-end
 
 > [!WARNING]
-> The default value of <xref:Microsoft.AspNetCore.SignalR.HubOptions.MaximumReceiveMessageSize> is 32 KB. Increasing the value may increase the risk of [Denial of service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks).
+> The default value of <xref:Microsoft.AspNetCore.SignalR.HubOptions.MaximumReceiveMessageSize> is 32 KB. Increasing the value may increase the risk of [Denial of Service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks).
 
 For information on memory management, see <xref:blazor/host-and-deploy/server#memory-management>.
 
@@ -304,7 +316,7 @@ builder.Services.AddRazorComponents().AddServerComponents()
     .AddHubOptions(options => options.MaximumReceiveMessageSize = 64 * 1024);
 ```
 
-Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
+Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of Service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
 
 A better option for reading large payloads is to send the content in smaller chunks and process the payload as a <xref:System.IO.Stream>. This can be used when reading large JavaScript (JS) interop JSON payloads or if JS interop data is available as raw bytes. For an example that demonstrates sending large binary payloads in server-side apps that uses techniques similar to the [`InputFile` component](xref:blazor/file-uploads), see the [Binary Submit sample app](https://github.com/aspnet/samples/tree/main/samples/aspnetcore/blazor/BinarySubmit) and the [Blazor `InputLargeTextArea` Component Sample](https://github.com/aspnet/samples/tree/main/samples/aspnetcore/blazor/InputLargeTextArea).
 
@@ -323,7 +335,7 @@ builder.Services.AddServerSideBlazor()
     .AddHubOptions(options => options.MaximumReceiveMessageSize = 64 * 1024);
 ```
 
-Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
+Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of Service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
 
 A better option for reading large payloads is to send the content in smaller chunks and process the payload as a <xref:System.IO.Stream>. This can be used when reading large JavaScript (JS) interop JSON payloads or if JS interop data is available as raw bytes. For an example that demonstrates sending large binary payloads in Blazor Server that uses techniques similar to the [`InputFile` component](xref:blazor/file-uploads), see the [Binary Submit sample app](https://github.com/aspnet/samples/tree/main/samples/aspnetcore/blazor/BinarySubmit) and the [Blazor `InputLargeTextArea` Component Sample](https://github.com/aspnet/samples/tree/main/samples/aspnetcore/blazor/InputLargeTextArea).
 
@@ -342,7 +354,7 @@ services.AddServerSideBlazor()
     .AddHubOptions(options => options.MaximumReceiveMessageSize = 64 * 1024);
 ```
 
-Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
+Increasing the SignalR incoming message size limit comes at the cost of requiring more server resources, and it increases the risk of [Denial of Service (DoS) attacks](xref:blazor/security/server/threat-mitigation#denial-of-service-dos-attacks). Additionally, reading a large amount of content in to memory as strings or byte arrays can also result in allocations that work poorly with the garbage collector, resulting in additional performance penalties.
 
 :::moniker-end
 
diff --git a/aspnetcore/blazor/includes/prerendering.md b/aspnetcore/blazor/includes/prerendering.md
index 4dcca493ae7d..370c9e13942c 100644
--- a/aspnetcore/blazor/includes/prerendering.md
+++ b/aspnetcore/blazor/includes/prerendering.md
@@ -12,7 +12,7 @@
 
 While an app is prerendering, certain actions, such as calling into JavaScript (JS), aren't possible.
 
-For the following example, the `setElementText1` function is placed inside the `<head>` element. The function is called with <xref:Microsoft.JSInterop.JSRuntimeExtensions.InvokeVoidAsync%2A?displayProperty=nameWithType> and doesn't return a value.
+For the following example, the `setElementText1` function is called with <xref:Microsoft.JSInterop.JSRuntimeExtensions.InvokeVoidAsync%2A?displayProperty=nameWithType> and doesn't return a value.
 
 > [!NOTE]
 > For general guidance on JS location and our recommendations for production apps, see <xref:blazor/js-interop/index#javascript-location>.
@@ -43,7 +43,7 @@ The [`OnAfterRender{Async}` lifecycle event](xref:blazor/components/lifecycle#af
 
 The following component demonstrates how to use JS interop as part of a component's initialization logic in a way that's compatible with prerendering. The component shows that it's possible to trigger a rendering update from inside <xref:Microsoft.AspNetCore.Components.ComponentBase.OnAfterRenderAsync%2A>. The developer must be careful to avoid creating an infinite loop in this scenario.
 
-For the following example, the `setElementText2` function is placed inside the `<head>` element. The function is called with <xref:Microsoft.JSInterop.IJSRuntime.InvokeAsync%2A?displayProperty=nameWithType> and returns a value.
+For the following example, the `setElementText2` function is called with <xref:Microsoft.JSInterop.IJSRuntime.InvokeAsync%2A?displayProperty=nameWithType> and returns a value.
 
 > [!NOTE]
 > For general guidance on JS location and our recommendations for production apps, see <xref:blazor/js-interop/index#javascript-location>.
diff --git a/aspnetcore/blazor/security/server/threat-mitigation.md b/aspnetcore/blazor/security/server/threat-mitigation.md
index da854a9c369f..2bf79643ec61 100644
--- a/aspnetcore/blazor/security/server/threat-mitigation.md
+++ b/aspnetcore/blazor/security/server/threat-mitigation.md
@@ -43,7 +43,7 @@ Resource exhaustion can occur when a client interacts with the server and causes
 * [Memory](#memory)
 * [Client connections](#client-connections)
 
-Denial of service (DoS) attacks usually seek to exhaust an app or server's resources. However, resource exhaustion isn't necessarily the result of an attack on the system. For example, finite resources can be exhausted due to high user demand. DoS is covered further in the [Denial of service (DoS) attacks](#denial-of-service-dos-attacks) section.
+Denial of Service (DoS) attacks usually seek to exhaust an app or server's resources. However, resource exhaustion isn't necessarily the result of an attack on the system. For example, finite resources can be exhausted due to high user demand. DoS is covered further in the [DoS section](#denial-of-service-dos-attacks).
 
 Resources external to the Blazor framework, such as databases and file handles (used to read and write files), may also experience resource exhaustion. For more information, see <xref:fundamentals/best-practices>.
 
@@ -123,9 +123,9 @@ By default, there's no limit on the number of connections per user for an app. I
 
 :::moniker-end
 
-## Denial of service (DoS) attacks
+## Denial of Service (DoS) attacks
 
-[Denial of service (DoS) attacks](https://developer.mozilla.org/docs/Glossary/DOS_attack) involve a client causing the server to exhaust one or more of its resources making the app unavailable. Blazor apps include default limits and rely on other ASP.NET Core and SignalR limits that are set on <xref:Microsoft.AspNetCore.Components.Server.CircuitOptions> to protect against DoS attacks:
+[Denial of Service (DoS) attacks](https://developer.mozilla.org/docs/Glossary/DOS_attack) involve a client causing the server to exhaust one or more of its resources making the app unavailable. Blazor apps include default limits and rely on other ASP.NET Core and SignalR limits that are set on <xref:Microsoft.AspNetCore.Components.Server.CircuitOptions> to protect against DoS attacks:
 
 * <xref:Microsoft.AspNetCore.Components.Server.CircuitOptions.DisconnectedCircuitMaxRetained?displayProperty=nameWithType>
 * <xref:Microsoft.AspNetCore.Components.Server.CircuitOptions.DisconnectedCircuitRetentionPeriod?displayProperty=nameWithType>
diff --git a/aspnetcore/blazor/security/webassembly/additional-scenarios.md b/aspnetcore/blazor/security/webassembly/additional-scenarios.md
index 95dc0c826ab7..50106251c819 100644
--- a/aspnetcore/blazor/security/webassembly/additional-scenarios.md
+++ b/aspnetcore/blazor/security/webassembly/additional-scenarios.md
@@ -1331,6 +1331,10 @@ Register the `CustomAccountFactory` for the authentication provider in use. Any
 
 For an additional example that works with ME-ID security groups and ME-ID Administrator Roles and a custom user account class, see <xref:blazor/security/webassembly/meid-groups-roles>.
 
+<!-- UPDATE 8.0 This entire scenario is based on hosted WASM.
+                A similar approach might need to be created
+                for WebAssembly rendering in BWAs -->
+
 :::moniker range="< aspnetcore-8.0"
 
 ## Prerendering with authentication
diff --git a/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md b/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
index 72d684015351..c4c3e232d3f1 100644
--- a/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
+++ b/aspnetcore/mvc/views/tag-helpers/built-in/component-tag-helper.md
@@ -10,11 +10,13 @@ uid: mvc/views/tag-helpers/builtin-th/component-tag-helper
 ---
 # Component Tag Helper in ASP.NET Core
 
+The Component Tag Helper renders a Razor component in a Razor Pages page or MVC view.
+
 ## Prerequisites
 
 :::moniker range=">= aspnetcore-8.0"
 
-Follow the guidance in the *Configuration* section of the <xref:blazor/components/integration> article.
+Follow the guidance in the *Use non-routable components in pages or views* section of the <xref:blazor/components/integration#use-non-routable-components-in-pages-or-views> article.
 
 :::moniker-end
 
@@ -37,9 +39,13 @@ Follow the guidance in the *Configuration* section of the <xref:blazor/component
 
 To render a component from a page or view, use the [Component Tag Helper](xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper) (`<component>` tag).
 
+:::moniker range="< aspnetcore-8.0"
+
 > [!NOTE]
 > Integrating Razor components into Razor Pages and MVC apps in a *hosted Blazor WebAssembly app* is supported in ASP.NET Core in .NET 5.0 or later.
 
+:::moniker-end
+
 <xref:Microsoft.AspNetCore.Mvc.Rendering.RenderMode> configures whether the component:
 
 * Is prerendered into the page.
@@ -83,30 +89,83 @@ Additional characteristics include:
 * While pages and views can use components, the converse isn't true. Components can't use view- and page-specific features, such as partial views and sections. To use logic from a partial view in a component, factor out the partial view logic into a component.
 * Rendering server components from a static HTML page isn't supported.
 
-The following Component Tag Helper renders the `Counter` component in a page or view in a server-side Blazor app with `ServerPrerendered`:
+The following Component Tag Helper renders the `EmbeddedCounter` component in a page or view in a server-side Blazor app with `ServerPrerendered`:
+
+:::moniker range=">= aspnetcore-8.0"
 
 ```cshtml
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
-@using {APP ASSEMBLY}.Pages
+@using {APP ASSEMBLY}.Components
 
 ...
 
-<component type="typeof(Counter)" render-mode="ServerPrerendered" />
+<component type="typeof(EmbeddedCounter)" render-mode="ServerPrerendered" />
 ```
 
-:::moniker range=">= aspnetcore-8.0"
+The preceding example assumes that the `EmbeddedCounter` component is in the app's `Components` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Components`).
+
+The Component Tag Helper can also pass parameters to components. Consider the following `ColorfulCheckbox` component that sets the checkbox label's color and size.
+
+`Components/ColorfulCheckbox.razor`:
+
+```razor
+<label style="font-size:@(Size)px;color:@Color">
+    <input @bind="Value"
+           id="survey" 
+           name="blazor" 
+           type="checkbox" />
+    Enjoying Blazor?
+</label>
+
+@code {
+    [Parameter]
+    public bool Value { get; set; }
+
+    [Parameter]
+    public int Size { get; set; } = 8;
+
+    [Parameter]
+    public string? Color { get; set; }
 
-The preceding example assumes that the `Counter` component is in the app's *Pages* folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Pages`).
+    protected override void OnInitialized()
+    {
+        Size += 10;
+    }
+}
+```
+
+The `Size` (`int`) and `Color` (`string`) [component parameters](xref:blazor/components/index#component-parameters) can be set by the Component Tag Helper:
+
+```cshtml
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+@using {APP ASSEMBLY}.Components
+
+...
+
+<component type="typeof(ColorfulCheckbox)" render-mode="ServerPrerendered" 
+    param-Size="14" param-Color="@("blue")" />
+```
+
+The preceding example assumes that the `ColorfulCheckbox` component is in the `Components` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Components`).
 
 :::moniker-end
 
 :::moniker range="< aspnetcore-8.0"
 
-The preceding example assumes that the `Counter` component is in the app's *Pages* folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Pages` or `@using BlazorSample.Client.Pages` in a hosted Blazor solution).
+```cshtml
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+@using {APP ASSEMBLY}.Shared
+
+...
 
-:::moniker-end
+<component type="typeof(EmbeddedCounter)" render-mode="ServerPrerendered" />
+```
 
-The Component Tag Helper can also pass parameters to components. Consider the following `ColorfulCheckbox` component that sets the checkbox label's color and size:
+The preceding example assumes that the `EmbeddedCounter` component is in the app's `Shared` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Shared` or `@using BlazorSample.Client.Shared` in a hosted Blazor solution).
+
+The Component Tag Helper can also pass parameters to components. Consider the following `ColorfulCheckbox` component that sets the checkbox label's color and size.
+
+`Shared/ColorfulCheckbox.razor`:
 
 ```razor
 <label style="font-size:@(Size)px;color:@Color">
@@ -125,7 +184,7 @@ The Component Tag Helper can also pass parameters to components. Consider the fo
     public int Size { get; set; } = 8;
 
     [Parameter]
-    public string Color { get; set; }
+    public string? Color { get; set; }
 
     protected override void OnInitialized()
     {
@@ -138,7 +197,7 @@ The `Size` (`int`) and `Color` (`string`) [component parameters](xref:blazor/com
 
 ```cshtml
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
-@using {APP ASSEMBLY}.Components
+@using {APP ASSEMBLY}.Shared
 
 ...
 
@@ -146,7 +205,9 @@ The `Size` (`int`) and `Color` (`string`) [component parameters](xref:blazor/com
     param-Size="14" param-Color="@("blue")" />
 ```
 
-The preceding example assumes that the `ColorfulCheckbox` component is in a *Components* folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Components`).
+The preceding example assumes that the `ColorfulCheckbox` component is in the `Shared` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample.Shared`).
+
+:::moniker-end
 
 The following HTML is rendered in the page or view:
 
@@ -187,18 +248,60 @@ public class MyClass
 
 **The class must have a public parameterless constructor.**
 
-`Shared/MyComponent.razor`:
+:::moniker range=">= aspnetcore-8.0"
+
+`Components/ParameterComponent.razor`:
+
+```razor
+<h2>ParameterComponent</h2>
+
+<p>Int: @MyObject?.MyInt</p>
+<p>String: @MyObject?.MyString</p>
+
+@code
+{
+    [Parameter]
+    public MyClass? MyObject { get; set; }
+}
+```
+
+`Pages/MyPage.cshtml`:
+
+```cshtml
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+@using {APP ASSEMBLY}
+@using {APP ASSEMBLY}.Components
+
+...
+
+@{
+    var myObject = new MyClass();
+    myObject.MyInt = 7;
+    myObject.MyString = "Set by MyPage";
+}
+
+<component type="typeof(ParameterComponent)" render-mode="ServerPrerendered" 
+    param-MyObject="@myObject" />
+```
+
+The preceding example assumes that the `ParameterComponent` component is in the app's `Components` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Components`). `MyClass` is in the app's namespace.
+
+:::moniker-end
+
+:::moniker range="< aspnetcore-8.0"
+
+`Shared/ParameterComponent.razor`:
 
 ```razor
-<h2>MyComponent</h2>
+<h2>ParameterComponent</h2>
 
-<p>Int: @MyObject.MyInt</p>
-<p>String: @MyObject.MyString</p>
+<p>Int: @MyObject?.MyInt</p>
+<p>String: @MyObject?.MyString</p>
 
 @code
 {
     [Parameter]
-    public MyClass MyObject { get; set; }
+    public MyClass? MyObject { get; set; }
 }
 ```
 
@@ -217,14 +320,41 @@ public class MyClass
     myObject.MyString = "Set by MyPage";
 }
 
-<component type="typeof(MyComponent)" render-mode="ServerPrerendered" 
+<component type="typeof(ParameterComponent)" render-mode="ServerPrerendered" 
     param-MyObject="@myObject" />
 ```
 
-The preceding example assumes that the `MyComponent` component is in the app's *Shared* folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Shared`). `MyClass` is in the app's namespace.
+The preceding example assumes that the `ParameterComponent` component is in the app's `Shared` folder. The placeholder `{APP ASSEMBLY}` is the app's assembly name (for example, `@using BlazorSample` and `@using BlazorSample.Shared`). `MyClass` is in the app's namespace.
+
+:::moniker-end
 
 ## Additional resources
 
+:::moniker range=">= aspnetcore-8.0"
+
+* <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>
+* <xref:blazor/components/prerender>
 * <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
 * <xref:mvc/views/tag-helpers/intro>
 * <xref:blazor/components/index>
+
+:::moniker-end
+
+:::moniker range=">= aspnetcore-6.0 < aspnetcore-8.0"
+
+* <xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper>
+* <xref:blazor/components/prerendering-and-integration>
+* <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
+* <xref:mvc/views/tag-helpers/intro>
+* <xref:blazor/components/index>
+
+:::moniker-end
+
+:::moniker range="< aspnetcore-6.0"
+
+* <xref:blazor/components/prerendering-and-integration>
+* <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
+* <xref:mvc/views/tag-helpers/intro>
+* <xref:blazor/components/index>
+
+:::moniker-end
diff --git a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
index 317a98e35331..88f45aa72358 100644
--- a/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
+++ b/aspnetcore/mvc/views/tag-helpers/built-in/persist-component-state.md
@@ -10,16 +10,13 @@ uid: mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper
 ---
 # Persist Component State Tag Helper in ASP.NET Core
 
-<!-- UPDATE 8.0 Content is TBD for the general concepts here -->
-
-> [!IMPORTANT]
-> This article is currently undergoing updates for .NET 8. Please check back periodically for new content or when .NET 8 is released.
+The Persist Component State Tag Helper saves the state of non-routable Razor components rendered in a page or view of a Razor Pages or MVC app.
 
 ## Prerequisites
 
 :::moniker range=">= aspnetcore-8.0"
 
-Follow the guidance in the *Configuration* section of the <xref:blazor/components/integration> article.
+Follow the guidance in the *Use non-routable components in pages or views* section of the <xref:blazor/components/integration#use-non-routable-components-in-pages-or-views> article.
 
 :::moniker-end
 
@@ -36,16 +33,23 @@ Follow the guidance in the *Configuration* section for either:
 
 :::moniker range=">= aspnetcore-8.0"
 
-<!-- UPDATE 8.0 Content is TBD for the general concepts here -->
+To persist state for prerendered components, use the [Persist Component State Tag Helper](xref:mvc/views/tag-helpers/builtin-th/persist-component-state-tag-helper) ([reference source](https://github.com/dotnet/aspnetcore/blob/main/src/Mvc/Mvc.TagHelpers/src/PersistComponentStateTagHelper.cs)). Add the Tag Helper's tag, `<persist-component-state />`, inside the closing `</body>` tag of the layout in an app that prerenders components.
+
+[!INCLUDE[](~/includes/aspnetcore-repo-ref-source-links.md)]
+
+In `Pages/Shared/_Layout.cshtml` for embedded components that are either WebAssembly prerendered (`WebAssemblyPrerendered`) or server prerendered (`ServerPrerendered`):
 
-> [!IMPORTANT]
-> This section is currently undergoing updates for .NET 8.
+```cshtml
+<body>
+    ...
 
-<!-- UPDATE 8.0
+    <persist-component-state />
+</body>
+```
 
-For more information, see <xref:blazor/components/prerender#persist-prerendered-state>.
+Decide what state to persist using the <xref:Microsoft.AspNetCore.Components.PersistentComponentState> service. [`PersistentComponentState.RegisterOnPersisting`](xref:Microsoft.AspNetCore.Components.PersistentComponentState.RegisterOnPersisting%2A) registers a callback to persist the component state before the app is paused. The state is retrieved when the application resumes.
 
--->
+For more information and examples, see <xref:blazor/components/prerender#persist-prerendered-state>.
 
 :::moniker-end
 
@@ -71,22 +75,24 @@ For more information and examples, see <xref:blazor/components/prerendering-and-
 
 :::moniker-end
 
-## Prerendered state size and SignalR message size limit
-
-*This section only applies to server-side Blazor apps.*
-
-A large prerendered state size may exceed the SignalR circuit message size limit, which results in the following:
+## Additional resources
 
-* The SignalR circuit fails to initialize with an error on the client: :::no-loc text="Circuit host not initialized.":::
-* The reconnection dialog on the client appears when the circuit fails. Recovery isn't possible.
+:::moniker range=">= aspnetcore-8.0"
 
-To resolve the problem, use ***either*** of the following approaches:
+* <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>
+* <xref:blazor/components/prerender>
+* <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
+* <xref:mvc/views/tag-helpers/intro>
+* <xref:blazor/components/index>
 
-* Reduce the amount of data that you are putting into the prerendered state.
-* Increase the [SignalR message size limit](xref:blazor/fundamentals/signalr#circuit-handler-options-for-blazor-server-apps). ***WARNING***: Increasing the limit may increase the risk of Denial of service (DoS) attacks.
+:::moniker-end
 
-## Additional resources
+:::moniker range="< aspnetcore-8.0"
 
+* <xref:mvc/views/tag-helpers/builtin-th/component-tag-helper>
+* <xref:blazor/components/prerendering-and-integration>
 * <xref:Microsoft.AspNetCore.Mvc.TagHelpers.ComponentTagHelper>
 * <xref:mvc/views/tag-helpers/intro>
 * <xref:blazor/components/index>
+
+:::moniker-end