fix(mf): initialize share scopes before consume loading

ScriptedAlchemy · ScriptedAlchemy · commit 91abbcd42417 · 2026-03-13T23:57:11.000-07:00
Wait for consume share scopes to finish initializing before delegating to the bundler runtime so layered shared modules resolve consistently. Remove the temporary federation debug instrumentation that was added while tracing the runtime flow.

Made-with: Cursor
diff --git a/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_mf.rs b/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_mf.rs
@@ -9,7 +9,7 @@ use rspack_plugin_mf::{
   ModuleFederationRuntimeExperimentsOptions, ModuleFederationRuntimePluginOptions,
   OptimizeSharedConfig, ProvideOptions, ProvideVersion, RemoteAliasTarget, RemoteOptions,
   ShareScope, SharedContainerPluginOptions, SharedUsedExportsOptimizerPluginOptions,
-  StatsBuildInfo, debug_log,
+  StatsBuildInfo,
 };
 use rspack_util::fx_hash::FxHashMap as HashMap;
 
@@ -136,35 +136,6 @@ pub struct RawProvideOptions {
 
 impl From<RawProvideOptions> for (String, ProvideOptions) {
   fn from(value: RawProvideOptions) -> Self {
-    // #region agent log
-    if value.share_key == "react" || value.layer.is_some() || value.request.is_some() {
-      debug_log(
-        "H1",
-        "raw_mf.rs:137",
-        "raw provide options converted",
-        serde_json::json!({
-          "key": value.key,
-          "request": value.request,
-          "layer": value.layer,
-          "shareKey": value.share_key,
-          "shareScope": match &value.share_scope {
-            Either::A(scope) => serde_json::json!(scope),
-            Either::B(scopes) => serde_json::json!(scopes),
-          },
-          "version": value.version.as_ref().map(|v| match v {
-            Either::A(version) => version.clone(),
-            Either::B(flag) => flag.to_string(),
-          }),
-          "requiredVersion": value.required_version.as_ref().map(|v| match v {
-            Either::A(version) => version.clone(),
-            Either::B(flag) => flag.to_string(),
-          }),
-          "singleton": value.singleton,
-          "strictVersion": value.strict_version,
-        }),
-      );
-    }
-    // #endregion
     (
       value.key,
       ProvideOptions {
@@ -317,35 +288,6 @@ pub struct RawConsumeOptions {
 
 impl From<RawConsumeOptions> for (String, ConsumeOptions) {
   fn from(value: RawConsumeOptions) -> Self {
-    // #region agent log
-    if value.share_key == "react" || value.layer.is_some() || value.issuer_layer.is_some() {
-      debug_log(
-        "H1",
-        "raw_mf.rs:289",
-        "raw consume options converted",
-        serde_json::json!({
-          "key": value.key,
-          "request": value.request,
-          "issuerLayer": value.issuer_layer,
-          "layer": value.layer,
-          "import": value.import,
-          "importResolved": value.import_resolved,
-          "shareKey": value.share_key,
-          "shareScope": match &value.share_scope {
-            Either::A(scope) => serde_json::json!(scope),
-            Either::B(scopes) => serde_json::json!(scopes),
-          },
-          "requiredVersion": value.required_version.as_ref().map(|v| match v {
-            Either::A(version) => version.clone(),
-            Either::B(flag) => flag.to_string(),
-          }),
-          "strictVersion": value.strict_version,
-          "singleton": value.singleton,
-          "eager": value.eager,
-        }),
-      );
-    }
-    // #endregion
     (
       value.key,
       ConsumeOptions {
diff --git a/crates/rspack_plugin_mf/src/container/container_entry_module.rs b/crates/rspack_plugin_mf/src/container/container_entry_module.rs
@@ -21,7 +21,7 @@ use rustc_hash::FxHashSet;
 use super::{
   container_exposed_dependency::ContainerExposedDependency, container_plugin::ExposeOptions,
 };
-use crate::{ShareScope, debug_log, utils::json_stringify};
+use crate::{ShareScope, utils::json_stringify};
 
 #[impl_source_map_config]
 #[cacheable]
@@ -344,18 +344,6 @@ impl Module for ContainerEntryModule {
     let module_map = ExposeModuleMap::new(compilation, self, runtime_template);
     let module_map_str = module_map.render(runtime_template);
     let source = if self.enhanced {
-      // #region agent log
-      debug_log(
-        "S1",
-        "container_entry_module.rs:346",
-        "rspack enhanced container entry codegen",
-        serde_json::json!({
-          "name": self.name,
-          "shareScope": self.share_scope,
-          "moduleMapKeys": self.exposes.iter().map(|(name, _)| name.clone()).collect::<Vec<_>>(),
-        }),
-      );
-      // #endregion
       let define_property_getters =
         runtime_template.render_runtime_globals(&RuntimeGlobals::DEFINE_PROPERTY_GETTERS);
       let get_container = format!(
diff --git a/crates/rspack_plugin_mf/src/container/embed_federation_runtime_module.rs b/crates/rspack_plugin_mf/src/container/embed_federation_runtime_module.rs
@@ -12,8 +12,6 @@ use rspack_core::{
 use rspack_error::Result;
 
 use super::module_federation_runtime_plugin::ModuleFederationRuntimeExperimentsOptions;
-use crate::debug_log;
-
 #[cacheable]
 #[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
 pub struct EmbedFederationRuntimeModuleOptions {
@@ -93,7 +91,6 @@ impl RuntimeModule for EmbedFederationRuntimeModule {
 
     // Generate module execution code for each federation runtime dependency
     let mut module_executions = String::with_capacity(federation_runtime_modules.len() * 64);
-    let federation_runtime_modules_count = federation_runtime_modules.len();
     let mut runtime_template = compilation.runtime_template.create_module_code_template();
 
     for dep_id in federation_runtime_modules {
@@ -102,24 +99,6 @@ impl RuntimeModule for EmbedFederationRuntimeModule {
       module_executions.push_str(&module_str);
       module_executions.push('\n');
     }
-    // #region agent log
-    debug_log(
-      "S3",
-      "embed_federation_runtime_module.rs:103",
-      "rspack embed federation runtime generate",
-      serde_json::json!({
-        "asyncStartup": self.options.experiments.async_startup,
-        "federationRuntimeModulesCount": federation_runtime_modules_count,
-        "entryChunk": compilation
-          .build_chunk_graph_artifact
-          .chunk_by_ukey
-          .expect_get(&chunk_ukey)
-          .id()
-          .map(ToString::to_string),
-      }),
-    );
-    // #endregion
-
     if self.options.experiments.async_startup {
       let entry_chunk_ids = compilation
         .build_chunk_graph_artifact
diff --git a/crates/rspack_plugin_mf/src/container/expose_runtime_module.rs b/crates/rspack_plugin_mf/src/container/expose_runtime_module.rs
@@ -4,7 +4,7 @@ use rspack_core::{
 };
 
 use super::container_entry_module::CodeGenerationDataExpose;
-use crate::{debug_log, utils::json_stringify};
+use crate::utils::json_stringify;
 
 #[impl_runtime_module]
 #[derive(Debug)]
@@ -69,16 +69,6 @@ impl RuntimeModule for ExposeRuntimeModule {
     let Some(data) = self.find_expose_data(&chunk_ukey, compilation) else {
       return Ok(String::new());
     };
-    // #region agent log
-    debug_log(
-      "S2",
-      "expose_runtime_module.rs:69",
-      "rspack expose runtime data",
-      serde_json::json!({
-        "shareScope": data.share_scope,
-      }),
-    );
-    // #endregion
     let mut runtime_template = compilation.runtime_template.create_module_code_template();
     let module_map = data.module_map.render(&mut runtime_template);
     let require_name = runtime_template.render_runtime_globals(&RuntimeGlobals::REQUIRE);
diff --git a/crates/rspack_plugin_mf/src/container/remote_runtime_module.rs b/crates/rspack_plugin_mf/src/container/remote_runtime_module.rs
@@ -11,7 +11,7 @@ use rustc_hash::FxHashMap;
 use serde::Serialize;
 
 use super::remote_module::RemoteModule;
-use crate::{ShareScope, debug_log, utils::json_stringify};
+use crate::{ShareScope, utils::json_stringify};
 
 static REMOTES_LOADING_TEMPLATE: &str = include_str!("./remotesLoading.ejs");
 static REMOTES_LOADING_RUNTIME_REQUIREMENTS: LazyLock<RuntimeGlobals> =
@@ -100,29 +100,6 @@ impl RuntimeModule for RemoteRuntimeModule {
           external_module.identifier(),
         )
         .expect("should have module_id at <RemoteRuntimeModule as RuntimeModule>::generate");
-        // #region agent log
-        if m.remote_key == "containerA" || matches!(share_scope, ShareScopeField::Multiple(_)) {
-          debug_log(
-            "H7",
-            "remote_runtime_module.rs:98",
-            "remote runtime mapping emitted",
-            serde_json::json!({
-              "moduleId": id.to_string(),
-              "remoteName": m.remote_key,
-              "request": name,
-              "shareScope": match &m.share_scope {
-                ShareScope::Single(scope) => serde_json::json!(scope),
-                ShareScope::Multiple(scopes) => serde_json::json!(scopes),
-              },
-              "externalModuleId": external_module_id,
-              "remoteInfo": remote_info.as_ref().map(|info| serde_json::json!({
-                "externalType": info.external_type,
-                "name": info.name,
-              })),
-            }),
-          );
-        }
-        // #endregion
         remotes.push(id.to_string());
         id_to_remote_data_mapping.insert(
           id,
diff --git a/crates/rspack_plugin_mf/src/lib.rs b/crates/rspack_plugin_mf/src/lib.rs
@@ -75,27 +75,3 @@ mod utils {
     serde_json::to_string(v).unwrap_or_else(|e| panic!("{e}: {v:?} should able to json stringify"))
   }
 }
-
-pub fn debug_log(hypothesis_id: &str, location: &str, message: &str, data: serde_json::Value) {
-  let timestamp = std::time::SystemTime::now()
-    .duration_since(std::time::UNIX_EPOCH)
-    .map(|duration| duration.as_millis())
-    .unwrap_or_default();
-  let payload = serde_json::json!({
-    "sessionId": "c5c28d",
-    "runId": "rust-stack-1",
-    "hypothesisId": hypothesis_id,
-    "location": location,
-    "message": message,
-    "data": data,
-    "timestamp": timestamp,
-  });
-  if let Ok(mut file) = std::fs::OpenOptions::new()
-    .create(true)
-    .append(true)
-    .open("/Users/zackjackson/rspack/.cursor/debug-c5c28d.log")
-  {
-    let _ = std::io::Write::write_all(&mut file, payload.to_string().as_bytes());
-    let _ = std::io::Write::write_all(&mut file, b"\n");
-  }
-}
diff --git a/crates/rspack_plugin_mf/src/sharing/consume_shared_plugin.rs b/crates/rspack_plugin_mf/src/sharing/consume_shared_plugin.rs
@@ -24,7 +24,7 @@ use super::{
   consume_shared_runtime_module::ConsumeSharedRuntimeModule, create_lookup_key_for_sharing,
   strip_lookup_layer_prefix,
 };
-use crate::{ShareScope, debug_log};
+use crate::ShareScope;
 
 #[cacheable]
 #[derive(Debug, Clone, Hash)]
@@ -359,29 +359,6 @@ impl ConsumeSharedPlugin {
     let required_version = self
       .get_required_version(context, request, config.clone(), add_diagnostic)
       .await;
-    // #region agent log
-    if config.share_key == "react" || config.layer.is_some() || config.issuer_layer.is_some() {
-      debug_log(
-        "H2",
-        "consume_shared_plugin.rs:359",
-        "create consume shared module",
-        serde_json::json!({
-          "request": request,
-          "context": context.as_str(),
-          "configRequest": config.request,
-          "issuerLayer": config.issuer_layer,
-          "layer": config.layer,
-          "import": config.import,
-          "importResolved": import_resolved.clone(),
-          "shareKey": config.share_key,
-          "shareScope": config.share_scope,
-          "requiredVersion": required_version.as_ref().map(ToString::to_string),
-          "singleton": config.singleton,
-          "eager": config.eager,
-        }),
-      );
-    }
-    // #endregion
     ConsumeSharedModule::new(
       if direct_fallback {
         self.get_context()
diff --git a/crates/rspack_plugin_mf/src/sharing/consume_shared_runtime_module.rs b/crates/rspack_plugin_mf/src/sharing/consume_shared_runtime_module.rs
@@ -10,7 +10,7 @@ use rspack_util::json_stringify_str;
 use rustc_hash::FxHashMap;
 
 use super::consume_shared_plugin::ConsumeVersion;
-use crate::{ShareScope, debug_log, utils::json_stringify};
+use crate::{ShareScope, utils::json_stringify};
 
 static CONSUMES_COMMON_TEMPLATE: &str = include_str!("./consumesCommon.ejs");
 static CONSUMES_INITIAL_TEMPLATE: &str = include_str!("./consumesInitial.ejs");
@@ -105,28 +105,6 @@ impl RuntimeModule for ConsumeSharedRuntimeModule {
         let fallback_source = code_gen
           .get(&SourceType::ConsumeShared)
           .map(|source| source.source().into_string_lossy().into_owned());
-        // #region agent log
-        if data.share_key == "react" || data.layer.is_some() {
-          debug_log(
-            "H6",
-            "consume_shared_runtime_module.rs:104",
-            "consume runtime mapping source",
-            serde_json::json!({
-              "moduleId": id,
-              "shareKey": data.share_key,
-              "shareScope": data.share_scope,
-              "requiredVersion": data.required_version.as_ref().map(ToString::to_string),
-              "strictVersion": data.strict_version,
-              "singleton": data.singleton,
-              "eager": data.eager,
-              "layer": data.layer,
-              "import": data.import,
-              "hasFallbackFactory": data.fallback.is_some(),
-              "hasFallbackSource": fallback_source.is_some(),
-            }),
-          );
-        }
-        // #endregion
         let share_scope_json = if enhanced {
           json_stringify(&data.share_scope)
         } else {
diff --git a/crates/rspack_plugin_mf/src/sharing/provide_shared_module.rs b/crates/rspack_plugin_mf/src/sharing/provide_shared_module.rs
@@ -21,7 +21,7 @@ use super::{
     CodeGenerationDataShareInit, DataInitInfo, ProvideSharedInfo, ShareInitData,
   },
 };
-use crate::{ConsumeVersion, ShareScope, debug_log};
+use crate::{ConsumeVersion, ShareScope};
 
 #[impl_source_map_config]
 #[cacheable]
@@ -216,26 +216,6 @@ impl Module for ProvideSharedModule {
     } else {
       runtime_template.async_module_factory(&self.get_blocks()[0], &self.request, compilation)
     };
-    // #region agent log
-    if self.name == "react" || self.layer.is_some() {
-      debug_log(
-        "H4",
-        "provide_shared_module.rs:214",
-        "provide shared module codegen",
-        serde_json::json!({
-          "request": self.request,
-          "shareKey": self.name,
-          "shareScope": self.share_scope,
-          "version": self.version.to_string(),
-          "eager": self.eager,
-          "singleton": self.singleton,
-          "requiredVersion": self.required_version.as_ref().map(ToString::to_string),
-          "strictVersion": self.strict_version,
-          "layer": self.layer,
-        }),
-      );
-    }
-    // #endregion
     code_generation_result
       .data
       .insert(CodeGenerationDataShareInit {
diff --git a/crates/rspack_plugin_mf/src/sharing/provide_shared_plugin.rs b/crates/rspack_plugin_mf/src/sharing/provide_shared_plugin.rs
diff --git a/crates/rspack_plugin_mf/src/sharing/share_runtime_module.rs b/crates/rspack_plugin_mf/src/sharing/share_runtime_module.rs
diff --git a/packages/rspack/src/runtime/moduleFederationDefaultRuntime.js b/packages/rspack/src/runtime/moduleFederationDefaultRuntime.js
