diff --git a/aspnetcore/blazor/components/event-handling.md b/aspnetcore/blazor/components/event-handling.md
index ddac0b2c41e0..329bbc87e638 100644
--- a/aspnetcore/blazor/components/event-handling.md
+++ b/aspnetcore/blazor/components/event-handling.md
@@ -97,22 +97,30 @@ Custom events with custom event arguments are generally enabled with the followi
    }
    ```
 
-1. Register the custom event with the preceding handler in `wwwroot/index.html` (Blazor WebAssembly) or `Pages/_Host.cshtml` (Blazor Server) immediately after the Blazor `<script>`:
+1. Register the custom event with the preceding handler in a [JavaScript initializer](xref:blazor/fundamentals/startup#javascript-initializers).
 
-   ```html
-   <script>
-     Blazor.registerCustomEventType('customevent', {
+   `wwwroot/{PACKAGE ID/ASSEMBLY NAME}.lib.module.js`:
+
+   ```javascript
+   export function afterStarted(blazor) {
+     blazor.registerCustomEventType('customevent', {
        createEventArgs: eventArgsCreator
      });
-   </script>
+   }
    ```
 
+   In the preceding example, the `{PACKAGE ID/ASSEMBLY NAME}` placeholder of the file name represents the package ID or assembly name of the app.
+
    > [!NOTE]
    > The call to `registerCustomEventType` is performed in a script only once per event.
+   >
+   > For the call to `registerCustomEventType`, use the `blazor` parameter (lowercase `b`) provided by `afterStarted`. Although the registration is valid when using the `Blazor` object (uppercase `B`), the preferred approach is to use the parameter.
 
 1. Define a class for the event arguments:
 
    ```csharp
+   namespace BlazorSample.CustomEvents;
+
    public class CustomEventArgs : EventArgs
    {
        public string? CustomProperty1 {get; set;}
@@ -120,9 +128,20 @@ Custom events with custom event arguments are generally enabled with the followi
    }
    ```
 
-1. Wire up the custom event with the event arguments by adding an <xref:Microsoft.AspNetCore.Components.EventHandlerAttribute> attribute annotation for the custom event. The class doesn't require members. Note that the class *must* be called `EventHandlers` in order to be found by the Razor compiler, but you should put it in a namespace specific to your app:
+1. Wire up the custom event with the event arguments by adding an <xref:Microsoft.AspNetCore.Components.EventHandlerAttribute> attribute annotation for the custom event:
+
+   * In order for the compiler to find the `[EventHandler]` class, it must be placed into a C# class file (`.cs`), making it a normal top-level class.
+   * Mark the class `public`.
+   * The class doesn't require members.
+   * The class *must* be called "`EventHandlers`" in order to be found by the Razor compiler.
+   * Place the class under a namespace specific to your app.
+   * Import the namespace into the Razor component (`.razor`) where the event is used.
 
    ```csharp
+   using Microsoft.AspNetCore.Components;
+
+   namespace BlazorSample.CustomEvents;
+
    [EventHandler("oncustomevent", typeof(CustomEventArgs), enableStopPropagation: true, enablePreventDefault: true)]
    public static class EventHandlers
    {
@@ -132,6 +151,8 @@ Custom events with custom event arguments are generally enabled with the followi
 1. Register the event handler on one or more HTML elements. Access the data that was passed in from JavaScript in the delegate handler method:
 
    ```razor
+   @using namespace BlazorSample.CustomEvents
+
    <button @oncustomevent="HandleCustomEvent">Handle</button>
 
    @code
@@ -159,6 +180,10 @@ Declare a custom name (`oncustompaste`) for the event and a .NET class (`CustomP
 `CustomEvents.cs`:
 
 ```csharp
+using Microsoft.AspNetCore.Components;
+
+namespace BlazorSample.CustomEvents;
+
 [EventHandler("oncustompaste", typeof(CustomPasteEventArgs), 
     enableStopPropagation: true, enablePreventDefault: true)]
 public static class EventHandlers
@@ -172,24 +197,29 @@ public class CustomPasteEventArgs : EventArgs
 }
 ```
 
-Add JavaScript code to supply data for the <xref:System.EventArgs> subclass. In the `wwwroot/index.html` or `Pages/_Host.cshtml` file, add the following `<script>` tag and content immediately after the Blazor script. The following example only handles pasting text, but you could use arbitrary JavaScript APIs to deal with users pasting other types of data, such as images.
+Add JavaScript code to supply data for the <xref:System.EventArgs> subclass with the preceding handler in a [JavaScript initializer](xref:blazor/fundamentals/startup#javascript-initializers). The following example only handles pasting text, but you could use arbitrary JavaScript APIs to deal with users pasting other types of data, such as images.
 
-`wwwroot/index.html` (Blazor WebAssembly) or `Pages/_Host.cshtml` (Blazor Server) immediately after the Blazor script:
+`wwwroot/{PACKAGE ID/ASSEMBLY NAME}.lib.module.js`:
 
-```html
-<script>
-  Blazor.registerCustomEventType('custompaste', {
-      browserEventName: 'paste',
-      createEventArgs: event => {
-        return {
-          eventTimestamp: new Date(),
-          pastedData: event.clipboardData.getData('text')
-        };
-      }
+```javascript
+export function afterStarted(blazor) {
+  blazor.registerCustomEventType('custompaste', {
+    browserEventName: 'paste',
+    createEventArgs: event => {
+      return {
+        eventTimestamp: new Date(),
+        pastedData: event.clipboardData.getData('text')
+      };
+    }
   });
-</script>
+}
 ```
 
+In the preceding example, the `{PACKAGE ID/ASSEMBLY NAME}` placeholder of the file name represents the package ID or assembly name of the app.
+
+> [!NOTE]
+> For the call to `registerCustomEventType`, use the `blazor` parameter (lowercase `b`) provided by `afterStarted`. Although the registration is valid when using the `Blazor` object (uppercase `B`), the preferred approach is to use the parameter.
+
 The preceding code tells the browser that when a native [`paste`](https://developer.mozilla.org/docs/Web/API/Element/paste_event) event occurs:
 
 * Raise a `custompaste` event.
@@ -208,6 +238,7 @@ In a Razor component, attach the custom handler to an element.
 
 ```razor
 @page "/custom-paste-arguments"
+@using BlazorSample.CustomEvents
 
 <label>
     Try pasting into the following text box:
@@ -434,22 +465,30 @@ Custom events with custom event arguments are generally enabled with the followi
    }
    ```
 
-1. Register the custom event with the preceding handler in `wwwroot/index.html` (Blazor WebAssembly) or `Pages/_Layout.cshtml` (Blazor Server) immediately after the Blazor `<script>`:
+1. Register the custom event with the preceding handler in a [JavaScript initializer](xref:blazor/fundamentals/startup#javascript-initializers).
 
-   ```html
-   <script>
-     Blazor.registerCustomEventType('customevent', {
+   `wwwroot/{PACKAGE ID/ASSEMBLY NAME}.lib.module.js`:
+
+   ```javascript
+   export function afterStarted(blazor) {
+     blazor.registerCustomEventType('customevent', {
        createEventArgs: eventArgsCreator
      });
-   </script>
+   }
    ```
 
+   In the preceding example, the `{PACKAGE ID/ASSEMBLY NAME}` placeholder of the file name represents the package ID or assembly name of the app.
+
    > [!NOTE]
    > The call to `registerCustomEventType` is performed in a script only once per event.
+   >
+   > For the call to `registerCustomEventType`, use the `blazor` parameter (lowercase `b`) provided by `afterStarted`. Although the registration is valid when using the `Blazor` object (uppercase `B`), the preferred approach is to use the parameter.
 
 1. Define a class for the event arguments:
 
    ```csharp
+   namespace BlazorSample.CustomEvents;
+
    public class CustomEventArgs : EventArgs
    {
        public string? CustomProperty1 {get; set;}
@@ -457,9 +496,20 @@ Custom events with custom event arguments are generally enabled with the followi
    }
    ```
 
-1. Wire up the custom event with the event arguments by adding an <xref:Microsoft.AspNetCore.Components.EventHandlerAttribute> attribute annotation for the custom event. The class doesn't require members. Note that the class *must* be called `EventHandlers` in order to be found by the Razor compiler, but you should put it in a namespace specific to your app:
+1. Wire up the custom event with the event arguments by adding an <xref:Microsoft.AspNetCore.Components.EventHandlerAttribute> attribute annotation for the custom event:
+
+   * In order for the compiler to find the `[EventHandler]` class, it must be placed into a C# class file (`.cs`), making it a normal top-level class.
+   * Mark the class `public`.
+   * The class doesn't require members.
+   * The class *must* be called "`EventHandlers`" in order to be found by the Razor compiler.
+   * Place the class under a namespace specific to your app.
+   * Import the namespace into the Razor component (`.razor`) where the event is used.
 
    ```csharp
+   using Microsoft.AspNetCore.Components;
+
+   namespace BlazorSample.CustomEvents;
+
    [EventHandler("oncustomevent", typeof(CustomEventArgs), enableStopPropagation: true, enablePreventDefault: true)]
    public static class EventHandlers
    {
@@ -469,6 +519,8 @@ Custom events with custom event arguments are generally enabled with the followi
 1. Register the event handler on one or more HTML elements. Access the data that was passed in from JavaScript in the delegate handler method:
 
    ```razor
+   @using namespace BlazorSample.CustomEvents
+
    <button @oncustomevent="HandleCustomEvent">Handle</button>
 
    @code
@@ -496,6 +548,10 @@ Declare a custom name (`oncustompaste`) for the event and a .NET class (`CustomP
 `CustomEvents.cs`:
 
 ```csharp
+using Microsoft.AspNetCore.Components;
+
+namespace BlazorSample.CustomEvents;
+
 [EventHandler("oncustompaste", typeof(CustomPasteEventArgs), 
     enableStopPropagation: true, enablePreventDefault: true)]
 public static class EventHandlers
@@ -509,24 +565,29 @@ public class CustomPasteEventArgs : EventArgs
 }
 ```
 
-Add JavaScript code to supply data for the <xref:System.EventArgs> subclass. In the `wwwroot/index.html` or `Pages/_Layout.cshtml` file, add the following `<script>` tag and content immediately after the Blazor script. The following example only handles pasting text, but you could use arbitrary JavaScript APIs to deal with users pasting other types of data, such as images.
+Add JavaScript code to supply data for the <xref:System.EventArgs> subclass with the preceding handler in a [JavaScript initializer](xref:blazor/fundamentals/startup#javascript-initializers). The following example only handles pasting text, but you could use arbitrary JavaScript APIs to deal with users pasting other types of data, such as images.
 
-`wwwroot/index.html` (Blazor WebAssembly) or `Pages/_Layout.cshtml` (Blazor Server) immediately after the Blazor script:
+`wwwroot/{PACKAGE ID/ASSEMBLY NAME}.lib.module.js`:
 
-```html
-<script>
-  Blazor.registerCustomEventType('custompaste', {
-      browserEventName: 'paste',
-      createEventArgs: event => {
-        return {
-          eventTimestamp: new Date(),
-          pastedData: event.clipboardData.getData('text')
-        };
-      }
+```javascript
+export function afterStarted(blazor) {
+  blazor.registerCustomEventType('custompaste', {
+    browserEventName: 'paste',
+    createEventArgs: event => {
+      return {
+        eventTimestamp: new Date(),
+        pastedData: event.clipboardData.getData('text')
+      };
+    }
   });
-</script>
+}
 ```
 
+In the preceding example, the `{PACKAGE ID/ASSEMBLY NAME}` placeholder of the file name represents the package ID or assembly name of the app.
+
+> [!NOTE]
+> For the call to `registerCustomEventType`, use the `blazor` parameter (lowercase `b`) provided by `afterStarted`. Although the registration is valid when using the `Blazor` object (uppercase `B`), the preferred approach is to use the parameter.
+
 The preceding code tells the browser that when a native [`paste`](https://developer.mozilla.org/docs/Web/API/Element/paste_event) event occurs:
 
 * Raise a `custompaste` event.
@@ -545,6 +606,7 @@ In a Razor component, attach the custom handler to an element.
 
 ```razor
 @page "/custom-paste-arguments"
+@using BlazorSample.CustomEvents
 
 <label>
     Try pasting into the following text box:
diff --git a/aspnetcore/blazor/components/js-spa-frameworks.md b/aspnetcore/blazor/components/js-spa-frameworks.md
index 58cf912c51e0..1b062fd76540 100644
--- a/aspnetcore/blazor/components/js-spa-frameworks.md
+++ b/aspnetcore/blazor/components/js-spa-frameworks.md
@@ -139,6 +139,34 @@ Quote &copy;1988-1999 Satellite of Love LLC: [*Mystery Science Theater 3000*](ht
 > rootComponent.dispose();
 > ```
 
+The preceding example dynamically renders the root component when the `showQuote()` JS function is called. To render a root component into a container element when Blazor starts, use a [JavaScript initializer](xref:blazor/fundamentals/startup#javascript-initializers) to render the component, as the following example demonstrates.
+
+The following example builds on the preceding example, using the `Quote` component, the root component registration in `Program.cs`, and the initialization of `jsComponentInitializers.js`. The `showQuote()` function (and the `script.js` file) aren't used.
+
+In HTML, place the target container element, `quoteContainer2` for this example:
+
+```html
+<div id="quoteContainer2"></div>
+```
+
+Using a [JavaScript initializer](xref:blazor/fundamentals/startup#javascript-initializers), add the root component to the target container element.
+
+`wwwroot/{PACKAGE ID/ASSEMBLY NAME}.lib.module.js`:
+
+```javascript
+export function afterStarted(blazor) {
+  let targetElement = document.getElementById('quoteContainer2');
+  blazor.rootComponents.add(targetElement, 'quote',
+    {
+      text: "Crow: I have my doubts that this movie is actually 'starring' " +
+          "anybody. More like, 'camera is generally pointed at.'"
+    });
+}
+```
+
+> [!NOTE]
+> For the call to `rootComponents.add`, use the `blazor` parameter (lowercase `b`) provided by `afterStarted`. Although the registration is valid when using the `Blazor` object (uppercase `B`), the preferred approach is to use the parameter.
+
 For an advanced example with additional features, see the example in the `BasicTestApp` of the ASP.NET Core reference source (`dotnet/aspnetcore` GitHub repository):
 
 * [`JavaScriptRootComponents.razor`](https://github.com/dotnet/aspnetcore/blob/main/src/Components/test/testassets/BasicTestApp/JavaScriptRootComponents.razor)
diff --git a/aspnetcore/blazor/fundamentals/startup.md b/aspnetcore/blazor/fundamentals/startup.md
index 46e052c103d9..0f26faf90289 100644
--- a/aspnetcore/blazor/fundamentals/startup.md
+++ b/aspnetcore/blazor/fundamentals/startup.md
@@ -12,7 +12,23 @@ uid: blazor/fundamentals/startup
 
 This article explains how to configure Blazor startup.
 
-The Blazor startup process via the Blazor script (`blazor.{webassembly|server}.js`) is automatic and asynchronous. The Blazor `<script>` tag is found in the `wwwroot/index.html` file (Blazor WebAssembly) or `Pages/_Host.cshtml` file (Blazor Server), except for the ASP.NET Core 6.0 release of Blazor Server (`Pages/_Layout.cshtml`).
+:::moniker range=">= aspnetcore-7.0"
+
+The Blazor startup process is automatic and asynchronous via the Blazor script (`blazor.{server|webassembly}.js`), where the `{server|webassembly}` placeholder is either `server` for Blazor Server or `webassembly` for Blazor WebAssembly. 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.
+
+:::moniker-end
+
+:::moniker range=">= aspnetcore-6.0 < aspnetcore-7.0"
+
+The Blazor startup process is automatic and asynchronous via the Blazor script (`blazor.{server|webassembly}.js`), where the `{server|webassembly}` placeholder is either `server` for Blazor Server or `webassembly` for Blazor WebAssembly. 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.
+
+:::moniker-end
+
+:::moniker range="< aspnetcore-6.0"
+
+The Blazor startup process is automatic and asynchronous via the Blazor script (`blazor.{server|webassembly}.js`), where the `{server|webassembly}` placeholder is either `server` for Blazor Server or `webassembly` for Blazor WebAssembly. 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.
+
+:::moniker-end
 
 To manually start Blazor:
 
@@ -36,8 +52,8 @@ To define a JS initializer, add a JS module to the project named `{NAME}.lib.mod
 The module exports either or both of the following conventional functions:
 
 * `beforeStart(options, extensions)`: Called before Blazor starts. For example, `beforeStart` is used to customize the loading process, logging level, and other options specific to the hosting model.
-  * In Blazor WebAssembly, `beforeStart` receives the Blazor WebAssembly options (`options` in this section's example) and any extensions (`extensions` in this section's example) added during publishing. For example, options can specify the use of a custom [boot resource loader](xref:blazor/fundamentals/startup#load-boot-resources).
-  * In Blazor Server, `beforeStart` receives SignalR circuit start options (`options` in this section's example).
+  * In Blazor WebAssembly, `beforeStart` receives the Blazor WebAssembly options (`options` in this section's examples) and any extensions (`extensions` in this section's examples) added during publishing. For example, options can specify the use of a custom [boot resource loader](xref:blazor/fundamentals/startup#load-boot-resources).
+  * In Blazor Server, `beforeStart` receives SignalR circuit start options (`options` in this section's examples).
   * In [`BlazorWebViews`](/mobile-blazor-bindings/walkthroughs/hybrid-hello-world#mainrazor-native-ui-page), no options are passed.
 * `afterStarted`: Called after Blazor is ready to receive calls from JS. For example, `afterStarted` is used to initialize libraries by making JS interop calls and registering custom elements. The Blazor instance is passed to `afterStarted` as an argument (`blazor` in this section's example).
 
@@ -46,7 +62,7 @@ For the filename:
 * If the JS initializers are consumed as a static asset in the project, use the format `{ASSEMBLY NAME}.lib.module.js`, where the `{ASSEMBLY NAME}` placeholder is the app's assembly name. For example, name the file `BlazorSample.lib.module.js` for a project with an assembly name of `BlazorSample`. Place the file in the app's `wwwroot` folder.
 * If the JS initializers are consumed from an RCL, use the format `{LIBRARY NAME/PACKAGE ID}.lib.module.js`, where the `{LIBRARY NAME/PACKAGE ID}` placeholder is the project's library name or package identifier. For example, name the file `RazorClassLibrary1.lib.module.js` for an RCL with a package identifier of `RazorClassLibrary1`. Place the file in the library's `wwwroot` folder.
 
-The following example demonstrates JS initializers that load custom scripts before and after Blazor has started:
+The following example demonstrates JS initializers that load custom scripts before and after Blazor has started by appending them to the `<head>` in `beforeStart` and `afterStarted`:
 
 ```javascript
 export function beforeStart(options, extensions) {
@@ -62,16 +78,74 @@ export function afterStarted(blazor) {
 }
 ```
 
+The preceding `beforeStart` example only guarantees that the custom script loads before Blazor starts. It doesn't guarantee that awaited promises in the script complete their execution before Blazor starts.
+
 > [!NOTE]
 > MVC and Razor Pages apps don't automatically load JS initializers. However, developer code can include a script to fetch the app's manifest and trigger the load of the JS initializers.
 
 For an examples of JS initializers, see the following resources:
 
+* <xref:blazor/components/js-spa-frameworks#render-razor-components-from-javascript> (*`quoteContainer2` example*)
+* <xref:blazor/components/event-handling#custom-event-arguments> (*Custom clipboard paste event example*)
 * <xref:blazor/host-and-deploy/webassembly-deployment-layout>
 * [Basic Test App in the ASP.NET Core GitHub repository (`BasicTestApp.lib.module.js`)](https://github.com/dotnet/aspnetcore/blob/main/src/Components/test/testassets/BasicTestApp/wwwroot/BasicTestApp.lib.module.js)
 
 [!INCLUDE[](~/includes/aspnetcore-repo-ref-source-links.md)]
 
+### Ensure libraries are loaded in a specific order
+
+Append custom scripts to the `<head>` in `beforeStart` and `afterStarted` in the order that they should load.
+
+The following example loads `script1.js` before `script2.js` and `script3.js` before `script4.js`:
+
+```javascript
+export function beforeStart(options, extensions) {
+    var customScript1 = document.createElement('script');
+    customScript1.setAttribute('src', 'script1.js');
+    document.head.appendChild(customScript1);
+
+    var customScript2 = document.createElement('script');
+    customScript2.setAttribute('src', 'script2.js');
+    document.head.appendChild(customScript2);
+}
+
+export function afterStarted(blazor) {
+    var customScript1 = document.createElement('script');
+    customScript1.setAttribute('src', 'script3.js');
+    document.head.appendChild(customScript1);
+
+    var customScript2 = document.createElement('script');
+    customScript2.setAttribute('src', 'script4.js');
+    document.head.appendChild(customScript2);
+}
+```
+
+### Import additional modules
+
+Use top-level [`import`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/import) statements in the JS initializers file (`*.lib.module.js`) to import additional modules.
+
+`additionalModule.js`:
+
+```javascript
+export function logMessage() {
+  console.log('logMessage is logging');
+}
+```
+
+```javascript
+import { logMessage } from "/additionalModule.js";
+
+export function beforeStart(options, extensions) {
+  ...
+
+  logMessage();
+}
+```
+
+### Import map
+
+[Import maps](https://developer.mozilla.org/docs/Web/HTML/Element/script/type/importmap) are supported by ASP.NET Core and Blazor.
+
 :::moniker-end
 
 ## Initialize Blazor when the document is ready
@@ -82,7 +156,7 @@ The following example starts Blazor when the document is ready:
 <body>
     ...
 
-    <script src="_framework/blazor.{webassembly|server}.js" autostart="false"></script>
+    <script src="_framework/blazor.{server|webassembly}.js" autostart="false"></script>
     <script>
       document.addEventListener("DOMContentLoaded", function() {
         Blazor.start();
@@ -91,7 +165,7 @@ The following example starts Blazor when the document is ready:
 </body>
 ```
 
-The `{webassembly|server}` placeholder in the preceding markup is either `webassembly` for a Blazor WebAssembly app (`blazor.webassembly.js`) or `server` for a Blazor Server app (`blazor.server.js`).
+The `{server|webassembly}` placeholder in the preceding markup is either `server` for a Blazor Server app or `webassembly` for a Blazor WebAssembly app.
 
 ## Chain to the `Promise` that results from a manual start
 
@@ -101,7 +175,7 @@ To perform additional tasks, such as JS interop initialization, use [`then`](htt
 <body>
     ...
 
-    <script src="_framework/blazor.{webassembly|server}.js" autostart="false"></script>
+    <script src="_framework/blazor.{server|webassembly}.js" autostart="false"></script>
     <script>
       Blazor.start().then(function () {
         ...
@@ -110,11 +184,15 @@ To perform additional tasks, such as JS interop initialization, use [`then`](htt
 </body>
 ```
 
-The `{webassembly|server}` placeholder in the preceding markup is either `webassembly` for a Blazor WebAssembly app (`blazor.webassembly.js`) or `server` for a Blazor Server app (`blazor.server.js`).
+The `{server|webassembly}` placeholder in the preceding markup is either `server` for a Blazor Server app or `webassembly` for a Blazor WebAssembly app.
+
+:::moniker range=">= aspnetcore-6.0"
 
 > [!NOTE]
 > For a library to automatically execute additional tasks after Blazor has started, use a [JavaScript initializer](#javascript-initializers). Use of a JS initializer doesn't require the consumer of the library to chain JS calls to Blazor's manual start.
 
+:::moniker-end
+
 ## Load boot resources
 
 *This section only applies to Blazor WebAssembly apps.*
diff --git a/aspnetcore/blazor/hybrid/class-libraries.md b/aspnetcore/blazor/hybrid/class-libraries.md
index 9a9f0a7d264b..0f9c9cdc2345 100644
--- a/aspnetcore/blazor/hybrid/class-libraries.md
+++ b/aspnetcore/blazor/hybrid/class-libraries.md
@@ -76,11 +76,11 @@ Component namespaces are derived from the RCL's package ID or assembly name and
 
 Place shared static assets in the RCL's `wwwroot` folder and update static asset paths in the app to use the following path format:
 
-> :::no-loc text="_content/{PACKAGE ID/ASSEMBLY}/{PATH}/{FILENAME}":::
+> :::no-loc text="_content/{PACKAGE ID/ASSEMBLY NAME}/{PATH}/{FILENAME}":::
 
 Placeholders:
 
-* `{PACKAGE ID/ASSEMBLY}`: The package ID or assembly name of the RCL.
+* `{PACKAGE ID/ASSEMBLY NAME}`: The package ID or assembly name of the RCL.
 * `{PATH}`: Optional path within the RCL's `wwwroot` folder.
 * `{FILENAME}`: The filename of the static asset.
 
diff --git a/aspnetcore/blazor/javascript-interoperability/call-dotnet-from-javascript.md b/aspnetcore/blazor/javascript-interoperability/call-dotnet-from-javascript.md
index 3243a69a16a8..54738159100b 100644
--- a/aspnetcore/blazor/javascript-interoperability/call-dotnet-from-javascript.md
+++ b/aspnetcore/blazor/javascript-interoperability/call-dotnet-from-javascript.md
@@ -734,7 +734,7 @@ For information on isolating scripts in [JS modules](https://developer.mozilla.o
 
 ## JavaScript isolation in JavaScript modules
 
-Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)).
+Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)). JavaScript module loading works the same way in Blazor as it does for other types of web apps, and you're free to customize how modules are defined in your app. For a guide on how to use JavaScript modules, see [MDN Web Docs: JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules).
 
 JS isolation provides the following benefits:
 
@@ -743,6 +743,16 @@ JS isolation provides the following benefits:
 
 For more information, see <xref:blazor/js-interop/call-javascript-from-dotnet#javascript-isolation-in-javascript-modules>.
 
+[Dynamic import with the `import()` operator](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/import) is supported with ASP.NET Core and Blazor:
+
+```javascript
+if ({CONDITION}) import("/additionalModule.js");
+```
+
+In the preceding example, the `{CONDITION}` placeholder represents a conditional check to determine if the module should be loaded.
+
+For browser compatibility, see [Can I use: JavaScript modules: dynamic import](https://caniuse.com/es6-module-dynamic-import).
+
 ## Avoid circular object references
 
 Objects that contain circular references can't be serialized on the client for either:
@@ -1606,7 +1616,7 @@ For information on isolating scripts in [JS modules](https://developer.mozilla.o
 
 ## JavaScript isolation in JavaScript modules
 
-Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)).
+Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)). JavaScript module loading works the same way in Blazor as it does for other types of web apps, and you're free to customize how modules are defined in your app. For a guide on how to use JavaScript modules, see [MDN Web Docs: JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules).
 
 JS isolation provides the following benefits:
 
@@ -1615,6 +1625,16 @@ JS isolation provides the following benefits:
 
 For more information, see <xref:blazor/js-interop/call-javascript-from-dotnet#javascript-isolation-in-javascript-modules>.
 
+[Dynamic import with the `import()` operator](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/import) is supported with ASP.NET Core and Blazor:
+
+```javascript
+if ({CONDITION}) import("/additionalModule.js");
+```
+
+In the preceding example, the `{CONDITION}` placeholder represents a conditional check to determine if the module should be loaded.
+
+For browser compatibility, see [Can I use: JavaScript modules: dynamic import](https://caniuse.com/es6-module-dynamic-import).
+
 ## Avoid circular object references
 
 Objects that contain circular references can't be serialized on the client for either:
@@ -2169,7 +2189,7 @@ Objects that contain circular references can't be serialized on the client for e
 
 ## JavaScript isolation in JavaScript modules
 
-Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)).
+Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)). JavaScript module loading works the same way in Blazor as it does for other types of web apps, and you're free to customize how modules are defined in your app. For a guide on how to use JavaScript modules, see [MDN Web Docs: JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules).
 
 JS isolation provides the following benefits:
 
@@ -2178,6 +2198,16 @@ JS isolation provides the following benefits:
 
 For more information, see <xref:blazor/js-interop/call-javascript-from-dotnet#javascript-isolation-in-javascript-modules>.
 
+[Dynamic import with the `import()` operator](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/import) is supported with ASP.NET Core and Blazor:
+
+```javascript
+if ({CONDITION}) import("/additionalModule.js");
+```
+
+In the preceding example, the `{CONDITION}` placeholder represents a conditional check to determine if the module should be loaded.
+
+For browser compatibility, see [Can I use: JavaScript modules: dynamic import](https://caniuse.com/es6-module-dynamic-import).
+
 ## Document Object Model (DOM) cleanup tasks during component disposal
 
 Don't execute JS interop code for DOM cleanup tasks during component disposal. Instead, use the [`MutationObserver`](https://developer.mozilla.org/docs/Web/API/MutationObserver) pattern in JavaScript on the client for the following reasons:
diff --git a/aspnetcore/blazor/javascript-interoperability/call-javascript-from-dotnet.md b/aspnetcore/blazor/javascript-interoperability/call-javascript-from-dotnet.md
index a4639861d74d..a337c8d1898d 100644
--- a/aspnetcore/blazor/javascript-interoperability/call-javascript-from-dotnet.md
+++ b/aspnetcore/blazor/javascript-interoperability/call-javascript-from-dotnet.md
@@ -178,13 +178,23 @@ For information on isolating scripts in [JS modules](https://developer.mozilla.o
 
 ## JavaScript isolation in JavaScript modules
 
-Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)).
+Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)). JavaScript module loading works the same way in Blazor as it does for other types of web apps, and you're free to customize how modules are defined in your app. For a guide on how to use JavaScript modules, see [MDN Web Docs: JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules).
 
 JS isolation provides the following benefits:
 
 * Imported JS no longer pollutes the global namespace.
 * Consumers of a library and components aren't required to import the related JS.
 
+[Dynamic import with the `import()` operator](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/import) is supported with ASP.NET Core and Blazor:
+
+```javascript
+if ({CONDITION}) import("/additionalModule.js");
+```
+
+In the preceding example, the `{CONDITION}` placeholder represents a conditional check to determine if the module should be loaded.
+
+For browser compatibility, see [Can I use: JavaScript modules: dynamic import](https://caniuse.com/es6-module-dynamic-import).
+
 For example, the following JS module exports a JS function for showing a [browser window prompt](https://developer.mozilla.org/docs/Web/API/Window/prompt). Place the following JS code in an external JS file.
 
 `wwwroot/scripts.js`:
@@ -954,13 +964,23 @@ For information on isolating scripts in [JS modules](https://developer.mozilla.o
 
 ## JavaScript isolation in JavaScript modules
 
-Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)).
+Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)). JavaScript module loading works the same way in Blazor as it does for other types of web apps, and you're free to customize how modules are defined in your app. For a guide on how to use JavaScript modules, see [MDN Web Docs: JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules).
 
 JS isolation provides the following benefits:
 
 * Imported JS no longer pollutes the global namespace.
 * Consumers of a library and components aren't required to import the related JS.
 
+[Dynamic import with the `import()` operator](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/import) is supported with ASP.NET Core and Blazor:
+
+```javascript
+if ({CONDITION}) import("/additionalModule.js");
+```
+
+In the preceding example, the `{CONDITION}` placeholder represents a conditional check to determine if the module should be loaded.
+
+For browser compatibility, see [Can I use: JavaScript modules: dynamic import](https://caniuse.com/es6-module-dynamic-import).
+
 For example, the following JS module exports a JS function for showing a [browser window prompt](https://developer.mozilla.org/docs/Web/API/Window/prompt). Place the following JS code in an external JS file.
 
 `wwwroot/scripts.js`:
@@ -1774,13 +1794,23 @@ For information on isolating scripts in [JS modules](https://developer.mozilla.o
 
 ## JavaScript isolation in JavaScript modules
 
-Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)).
+Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)). JavaScript module loading works the same way in Blazor as it does for other types of web apps, and you're free to customize how modules are defined in your app. For a guide on how to use JavaScript modules, see [MDN Web Docs: JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules).
 
 JS isolation provides the following benefits:
 
 * Imported JS no longer pollutes the global namespace.
 * Consumers of a library and components aren't required to import the related JS.
 
+[Dynamic import with the `import()` operator](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/import) is supported with ASP.NET Core and Blazor:
+
+```javascript
+if ({CONDITION}) import("/additionalModule.js");
+```
+
+In the preceding example, the `{CONDITION}` placeholder represents a conditional check to determine if the module should be loaded.
+
+For browser compatibility, see [Can I use: JavaScript modules: dynamic import](https://caniuse.com/es6-module-dynamic-import).
+
 For example, the following JS module exports a JS function for showing a [browser window prompt](https://developer.mozilla.org/docs/Web/API/Window/prompt). Place the following JS code in an external JS file.
 
 `wwwroot/scripts.js`:
diff --git a/aspnetcore/blazor/javascript-interoperability/index.md b/aspnetcore/blazor/javascript-interoperability/index.md
index 83db20b73aec..61662ef29123 100644
--- a/aspnetcore/blazor/javascript-interoperability/index.md
+++ b/aspnetcore/blazor/javascript-interoperability/index.md
@@ -570,7 +570,7 @@ To inject a script after Blazor starts, chain to the `Promise` that results from
 
 ## JavaScript isolation in JavaScript modules
 
-Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)).
+Blazor enables JavaScript (JS) isolation in standard [JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules) ([ECMAScript specification](https://tc39.es/ecma262/#sec-modules)). JavaScript module loading works the same way in Blazor as it does for other types of web apps, and you're free to customize how modules are defined in your app. For a guide on how to use JavaScript modules, see [MDN Web Docs: JavaScript modules](https://developer.mozilla.org/docs/Web/JavaScript/Guide/Modules).
 
 JS isolation provides the following benefits:
 
@@ -579,6 +579,16 @@ JS isolation provides the following benefits:
 
 For more information, see <xref:blazor/js-interop/call-javascript-from-dotnet#javascript-isolation-in-javascript-modules>.
 
+[Dynamic import with the `import()` operator](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/import) is supported with ASP.NET Core and Blazor:
+
+```javascript
+if ({CONDITION}) import("/additionalModule.js");
+```
+
+In the preceding example, the `{CONDITION}` placeholder represents a conditional check to determine if the module should be loaded.
+
+For browser compatibility, see [Can I use: JavaScript modules: dynamic import](https://caniuse.com/es6-module-dynamic-import).
+
 ## Cached JavaScript files
 
 JavaScript (JS) files and other static assets aren't generally cached on clients during development in the [`Development` environment](xref:fundamentals/index#environments). During development, static asset requests include the [`Cache-Control` header](https://developer.mozilla.org/docs/Web/HTTP/Headers/Cache-Control) with a value of [`no-cache`](https://developer.mozilla.org/docs/Web/HTTP/Headers/Cache-Control#cacheability) or [`max-age`](https://developer.mozilla.org/docs/Web/HTTP/Headers/Cache-Control#expiration) with a value of zero (`0`).