feat(mf): initialize ordered share scopes at runtime

crates/rspack_plugin_mf/src/container/embed_federation_runtime_async.ejs

@@ -18,7 +18,7 @@
 		hasRun = true;
 		var base = mfStartupBase && mfStartupBase();
 		var promises = base && base.then ? [base] : [];
-		var handlers = <%- REQUIRE %>.f;
+		var handlers = <%- ENSURE_CHUNK_HANDLERS %>;
 		if (handlers) {
 			var startupChunkIds = <%- _entry_chunk_ids %>;
 			for (var i = 0; i < startupChunkIds.length; i++) {

crates/rspack_plugin_mf/src/container/embed_federation_runtime_module.rs

@@ -26,7 +26,6 @@ static RUNTIME_MODULE_VARIABLES: LazyLock<Vec<&'static str>> = LazyLock::new(||
     EMBED_FEDERATION_RUNTIME_SYNC_TEMPLATE,
   ])
 });
-
 #[cacheable]
 #[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
 pub struct EmbedFederationRuntimeModuleOptions {
@@ -74,6 +73,7 @@ impl RuntimeModule for EmbedFederationRuntimeModule {
     _compilation: &Compilation,
   ) -> rspack_core::RuntimeModuleRuntimeRequirements {
     let mut define = RuntimeGlobals::STARTUP;
+    // `async_startup` is resolved per runtime chunk by EmbedFederationRuntimePlugin.
     if self.options.experiments.async_startup {
       define.insert(RuntimeGlobals::STARTUP_ENTRYPOINT);
     }
@@ -133,7 +133,6 @@ impl RuntimeModule for EmbedFederationRuntimeModule {
       module_executions.push_str(&module_str);
       module_executions.push('\n');
     }
-
     if self.options.experiments.async_startup {
       let entry_chunk_ids = compilation
         .build_chunk_graph_artifact

crates/rspack_plugin_mf/src/container/embed_federation_runtime_plugin.rs

@@ -88,7 +88,10 @@ async fn additional_chunk_runtime_requirements_tree(
     // Add STARTUP (sync) so the runtime wrapper can always hook __rspack_require.x,
     // and STARTUP_ENTRYPOINT (async) when async startup is enabled.
     runtime_requirements.insert(RuntimeGlobals::STARTUP);
-    if self.experiments.async_startup {
+    if self
+      .experiments
+      .needs_async_startup(compilation, chunk_ukey)
+    {
       runtime_requirements.insert(RuntimeGlobals::STARTUP_ENTRYPOINT);
       runtime_requirements.insert(RuntimeGlobals::ENSURE_CHUNK_HANDLERS);
     }
@@ -129,9 +132,16 @@ async fn runtime_requirement_in_tree(
       .copied()
       .collect::<Vec<DependencyId>>();
 
+    // Resolve the startup mode here, where the chunk graph is available; the
+    // runtime module's `runtime_requirements` runs before it is attached to a
+    // chunk.
     let emro = EmbedFederationRuntimeModuleOptions {
       collected_dependency_ids: collected_ids_snapshot,
-      experiments: self.experiments.clone(),
+      experiments: ModuleFederationRuntimeExperimentsOptions {
+        async_startup: self
+          .experiments
+          .needs_async_startup(compilation, chunk_ukey),
+      },
     };
 
     // Inject EmbedFederationRuntimeModule
@@ -225,7 +235,10 @@ async fn render_startup(
 
   // Entry chunks delegating to runtime need explicit startup calls (sync only)
   if !has_runtime && has_entry_modules {
-    if self.experiments.async_startup {
+    if self
+      .experiments
+      .needs_async_startup(compilation, chunk_ukey)
+    {
       return Ok(());
     }
     let mut startup_with_call = ConcatSource::default();

crates/rspack_plugin_mf/src/container/module_federation_runtime_plugin.rs

@@ -5,10 +5,9 @@
 
 use rspack_cacheable::cacheable;
 use rspack_core::{
-  AsyncModulesArtifact, BoxDependency, ChunkUkey, Compilation,
-  CompilationAdditionalTreeRuntimeRequirements, CompilationFinishModules, CompilationParams,
-  CompilerCompilation, CompilerFinishMake, DependencyType, EntryOptions, ExportsInfoArtifact,
-  Plugin, RuntimeGlobals, RuntimeModule, SideEffectsStateArtifact,
+  BoxDependency, ChunkUkey, Compilation, CompilationAdditionalTreeRuntimeRequirements,
+  CompilationOptimizeChunkModules, CompilationParams, CompilerCompilation, CompilerFinishMake,
+  DependencyType, EntryOptions, Plugin, RuntimeGlobals, RuntimeModule, SourceType,
 };
 use rspack_error::Result;
 use rspack_hook::{plugin, plugin_hook};
@@ -22,6 +21,7 @@ use super::{
   federation_runtime_dependency::FederationRuntimeDependency,
   hoist_container_references_plugin::HoistContainerReferencesPlugin,
 };
+use crate::{ShareScope, sharing::consume_shared_module::ConsumeSharedModule};
 
 #[derive(Debug, Default, Deserialize, Clone)]
 pub struct ModuleFederationRuntimePluginOptions {
@@ -37,6 +37,68 @@ pub struct ModuleFederationRuntimeExperimentsOptions {
   pub async_startup: bool,
 }
 
+impl ModuleFederationRuntimeExperimentsOptions {
+  /// Whether the startup of `chunk_ukey` must be asynchronous.
+  ///
+  /// Ordered (array) share scopes are initialized before their consumes are
+  /// installed, so a runtime whose initial chunks contain such a consume must
+  /// await that initialization. This is derived from the actual initial
+  /// `ConsumeSharedModule`s rather than only from the high-level `shared`
+  /// option, so consumes contributed by a separately installed enhanced
+  /// `ConsumeSharedPlugin` are covered too. Scalar scopes keep synchronous
+  /// startup.
+  ///
+  /// The decision is owned by the runtime chunk: the runtime installs the
+  /// initial consumes of every entry it serves in one call, so an entry chunk
+  /// that delegates to a shared runtime (`runtimeChunk: 'single'`) must take
+  /// the same mode as that runtime even when its own initial chunks contain
+  /// no ordered consume.
+  pub fn needs_async_startup(&self, compilation: &Compilation, chunk_ukey: &ChunkUkey) -> bool {
+    if self.async_startup {
+      return true;
+    }
+    let artifact = &compilation.build_chunk_graph_artifact;
+    let chunk = artifact.chunk_by_ukey.expect_get(chunk_ukey);
+    let mut runtime_chunks: Vec<ChunkUkey> = chunk
+      .groups()
+      .iter()
+      .filter_map(|group_ukey| artifact.chunk_group_by_ukey.get(group_ukey))
+      .filter(|group| group.kind.is_entrypoint())
+      .map(|group| group.get_runtime_chunk(&artifact.chunk_group_by_ukey))
+      .collect();
+    if runtime_chunks.is_empty() {
+      runtime_chunks.push(*chunk_ukey);
+    }
+    runtime_chunks.sort_unstable();
+    runtime_chunks.dedup();
+
+    let module_graph = compilation.get_module_graph();
+    runtime_chunks
+      .iter()
+      .flat_map(|runtime_chunk| {
+        artifact
+          .chunk_by_ukey
+          .expect_get(runtime_chunk)
+          .get_all_initial_chunks(&artifact.chunk_group_by_ukey)
+      })
+      .flat_map(|chunk| {
+        artifact
+          .chunk_graph
+          .get_chunk_modules_identifier_by_source_type(
+            &chunk,
+            SourceType::ConsumeShared,
+            module_graph,
+          )
+      })
+      .any(|module_identifier| {
+        module_graph
+          .module_by_identifier(&module_identifier)
+          .and_then(|module| module.as_any().downcast_ref::<ConsumeSharedModule>())
+          .is_some_and(|module| matches!(module.share_scope(), ShareScope::Multiple(_)))
+      })
+  }
+}
+
 #[plugin]
 #[derive(Debug)]
 pub struct ModuleFederationRuntimePlugin {
@@ -102,35 +164,38 @@ async fn finish_make(&self, compilation: &mut Compilation) -> Result<()> {
   Ok(())
 }
 
-// When MF async startup is enabled, STARTUP may resolve asynchronously even if the entry module
-// itself doesn't have top-level await. Mark MF container entry modules as async so downstream
-// renderers (e.g. library wrappers) can safely `await` exports without sprinkling MF-specific
-// RuntimeGlobals checks across generic plugins.
-#[plugin_hook(CompilationFinishModules for ModuleFederationRuntimePlugin, stage = 1000)]
-async fn finish_modules(
-  &self,
-  compilation: &Compilation,
-  async_modules_artifact: &mut AsyncModulesArtifact,
-  _exports_info_artifact: &mut ExportsInfoArtifact,
-  _side_effects_state_artifact: &mut SideEffectsStateArtifact,
-) -> Result<()> {
-  if !self.options.experiments.async_startup {
-    return Ok(());
-  }
-
+// Container startup can return a promise independently of module-level await.
+// Wait for the chunk graph so async-only consumes and separate runtimes do not
+// make synchronous containers acquire top-level await in module-library output.
+#[plugin_hook(CompilationOptimizeChunkModules for ModuleFederationRuntimePlugin, stage = -1)]
+async fn optimize_chunk_modules(&self, compilation: &mut Compilation) -> Result<Option<bool>> {
   let module_graph = compilation.get_module_graph();
-  for (module_identifier, module) in module_graph.modules() {
-    if module
-      .as_ref()
-      .as_any()
-      .downcast_ref::<ContainerEntryModule>()
-      .is_some()
-    {
-      async_modules_artifact.insert(*module_identifier);
-    }
-  }
-
-  Ok(())
+  let async_containers: Vec<_> = module_graph
+    .modules()
+    .filter(|(_, module)| {
+      module
+        .as_ref()
+        .as_any()
+        .downcast_ref::<ContainerEntryModule>()
+        .is_some()
+    })
+    .filter(|(module_identifier, _)| {
+      compilation
+        .build_chunk_graph_artifact
+        .chunk_graph
+        .get_module_chunks(**module_identifier)
+        .iter()
+        .any(|chunk| {
+          self
+            .options
+            .experiments
+            .needs_async_startup(compilation, chunk)
+        })
+    })
+    .map(|(module_identifier, _)| *module_identifier)
+    .collect();
+  compilation.async_modules_artifact.extend(async_containers);
+  Ok(None)
 }
 
 impl Plugin for ModuleFederationRuntimePlugin {
@@ -148,8 +213,8 @@ impl Plugin for ModuleFederationRuntimePlugin {
 
     ctx
       .compilation_hooks
-      .finish_modules
-      .tap(finish_modules::new(self));
+      .optimize_chunk_modules
+      .tap(optimize_chunk_modules::new(self));
 
     ctx.compiler_hooks.finish_make.tap(finish_make::new(self));
 

crates/rspack_plugin_mf/src/container/remote_module.rs

@@ -58,8 +58,8 @@ impl RemoteModule {
     Self {
       dependencies_block: Default::default(),
       identifier: ModuleIdentifier::from(format!(
-        "remote ({}) {} {}",
-        share_scope.key(),
+        "remote {} {} {}",
+        share_scope.identifier_fragment(),
         external_requests.join(" "),
         internal_request
       )),

crates/rspack_plugin_mf/src/container/remote_runtime_module.rs

@@ -2,18 +2,18 @@ use std::sync::LazyLock;
 
 use rspack_collections::Identifiable;
 use rspack_core::{
-  ChunkGraph, Compilation, DependenciesBlock, ModuleId, RuntimeGlobals, RuntimeModule,
-  RuntimeModuleGenerateContext, RuntimeModuleRuntimeRequirements, RuntimeModuleStage,
-  RuntimeTemplate, SourceType, impl_runtime_module,
+  ChunkGraph, Compilation, DependenciesBlock, ExternalModule, ModuleId, RuntimeGlobals,
+  RuntimeModule, RuntimeModuleGenerateContext, RuntimeModuleRuntimeRequirements,
+  RuntimeModuleStage, RuntimeTemplate, SourceType, extract_url_and_global, impl_runtime_module,
 };
 use rspack_plugin_runtime::extract_runtime_globals_from_ejs;
 use rustc_hash::FxHashMap;
 use serde::Serialize;
 
-use super::remote_module::RemoteModule;
+use super::{fallback_module::FallbackModule, remote_module::RemoteModule};
 use crate::{
   ShareScope,
-  utils::{json_stringify, runtime_require_scope_name, runtime_require_scope_requirement},
+  utils::{runtime_require_scope_name, runtime_require_scope_requirement},
 };
 
 static REMOTES_LOADING_TEMPLATE: &str = include_str!("./remotesLoading.ejs");
@@ -105,6 +105,29 @@ impl RuntimeModule for RemoteRuntimeModule {
         let external_module = module_graph
           .get_module_by_dependency_id(dep)
           .expect("should have module");
+        let remote_infos = if self.enhanced {
+          if let Some(external_module) = external_module.downcast_ref::<ExternalModule>() {
+            vec![RemoteInfo::from(external_module)]
+          } else if let Some(fallback_module) = external_module.downcast_ref::<FallbackModule>() {
+            fallback_module
+              .get_dependency_ids()
+              .map(|dep| {
+                module_graph
+                  .get_module_by_dependency_id(dep)
+                  .and_then(|module| module.downcast_ref::<ExternalModule>())
+                  .map(RemoteInfo::from)
+                  .unwrap_or(RemoteInfo {
+                    external_type: "",
+                    name: "",
+                  })
+              })
+              .collect()
+          } else {
+            vec![]
+          }
+        } else {
+          vec![]
+        };
         let external_module_id = ChunkGraph::get_module_id(
           &compilation.module_ids_artifact,
           external_module.identifier(),
@@ -118,6 +141,7 @@ impl RuntimeModule for RemoteRuntimeModule {
             name,
             external_module_id,
             remote_name: &m.remote_key,
+            remote_infos,
           },
         );
       }
@@ -151,23 +175,52 @@ impl RuntimeModule for RemoteRuntimeModule {
 {remotes_loading_impl}
 "#,
       require_name = runtime_require_scope_name(runtime_template),
-      chunk_mapping = json_stringify(&chunk_to_remotes_mapping),
-      id_to_remote_data_mapping = json_stringify(&id_to_remote_data_mapping),
+      chunk_mapping =
+        simd_json::to_string(&chunk_to_remotes_mapping).expect("valid remote chunk mapping"),
+      id_to_remote_data_mapping =
+        simd_json::to_string(&id_to_remote_data_mapping).expect("valid remote data"),
       remotes_loading_impl = remotes_loading_impl,
     ))
   }
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct RemoteData<'a> {
   share_scope: ShareScopeField<'a>,
   name: &'a str,
   external_module_id: &'a ModuleId,
   remote_name: &'a str,
+  #[serde(skip_serializing_if = "Vec::is_empty")]
+  remote_infos: Vec<RemoteInfo<'a>>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct RemoteInfo<'a> {
+  external_type: &'a str,
+  name: &'a str,
+}
+
+impl<'a> From<&'a ExternalModule> for RemoteInfo<'a> {
+  fn from(external_module: &'a ExternalModule) -> Self {
+    let external_type = external_module.get_external_type().as_str();
+    let name = if external_type == "script" {
+      match extract_url_and_global(external_module.get_request().primary()) {
+        Ok(url_and_global) => url_and_global.global,
+        Err(_) => "",
+      }
+    } else {
+      ""
+    };
+    Self {
+      external_type,
+      name,
+    }
+  }
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Serialize)]
 #[serde(untagged)]
 enum ShareScopeField<'a> {
   Single(&'a str),

crates/rspack_plugin_mf/src/lib.rs

@@ -144,16 +144,14 @@ pub use sharing::{
 };
 
 mod utils {
-  use std::fmt;
-
   use rspack_core::{
     Compilation, ModuleCodeTemplate, RuntimeCodeTemplate, RuntimeGlobals, RuntimeGlobalsRenderMode,
     RuntimeVariable, runtime_mode::RuntimeMode,
   };
   use serde::Serialize;
 
-  pub fn json_stringify<T: ?Sized + Serialize + fmt::Debug>(v: &T) -> String {
-    simd_json::to_string(v).unwrap_or_else(|e| panic!("{e}: {v:?} should able to json stringify"))
+  pub fn json_stringify<T: ?Sized + Serialize>(v: &T) -> String {
+    simd_json::to_string(v).expect("valid JSON")
   }
 
   pub fn module_identifier_namespace(runtime_mode: RuntimeMode) -> &'static str {