feat(mf): add layers support for module federation

ScriptedAlchemy · ScriptedAlchemy · commit b24161934e35 · 2026-03-13T21:37:04.000-07:00
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,
+  StatsBuildInfo, debug_log,
 };
 use rspack_util::fx_hash::FxHashMap as HashMap;
 
@@ -136,6 +136,35 @@ 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 {
@@ -288,6 +317,35 @@ 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, utils::json_stringify};
+use crate::{ShareScope, debug_log, utils::json_stringify};
 
 #[impl_source_map_config]
 #[cacheable]
@@ -344,6 +344,18 @@ 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,6 +12,7 @@ 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)]
@@ -92,6 +93,7 @@ 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 {
@@ -100,6 +102,23 @@ 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
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::utils::json_stringify;
+use crate::{debug_log, utils::json_stringify};
 
 #[impl_runtime_module]
 #[derive(Debug)]
@@ -69,6 +69,16 @@ 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, utils::json_stringify};
+use crate::{ShareScope, debug_log, utils::json_stringify};
 
 static REMOTES_LOADING_TEMPLATE: &str = include_str!("./remotesLoading.ejs");
 static REMOTES_LOADING_RUNTIME_REQUIREMENTS: LazyLock<RuntimeGlobals> =
@@ -100,6 +100,29 @@ 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,3 +75,27 @@ 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;
+use crate::{ShareScope, debug_log};
 
 #[cacheable]
 #[derive(Debug, Clone, Hash)]
@@ -359,6 +359,29 @@ 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, utils::json_stringify};
+use crate::{ShareScope, debug_log, utils::json_stringify};
 
 static CONSUMES_COMMON_TEMPLATE: &str = include_str!("./consumesCommon.ejs");
 static CONSUMES_INITIAL_TEMPLATE: &str = include_str!("./consumesInitial.ejs");
@@ -105,6 +105,28 @@ 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};
+use crate::{ConsumeVersion, ShareScope, debug_log};
 
 #[impl_source_map_config]
 #[cacheable]
@@ -216,6 +216,26 @@ 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
