fix(mf): harden layered manifest and optimizer metadata

Preserve layer-aware shared metadata across manifest generation, used-exports optimization, and module remote runtime wiring so layered federation outputs stay correct and covered.

Made-with: Cursor

Author: ScriptedAlchemy

crates/node_binding/napi-binding.d.ts

@@ -2548,6 +2548,7 @@ export interface RawManifestSharedOption {
   name: string
   version?: string
   requiredVersion?: string
+  layer?: string
   singleton?: boolean
 }
 
@@ -2690,6 +2691,7 @@ export interface RawOptimizeSharedConfig {
   shareKey: string
   treeShaking: boolean
   usedExports?: Array<string>
+  layer?: string
 }
 
 export interface RawOptions {

crates/rspack_binding_api/src/raw_options/raw_builtins/raw_mf.rs

@@ -226,6 +226,7 @@ pub struct RawOptimizeSharedConfig {
   pub share_key: String,
   pub tree_shaking: bool,
   pub used_exports: Option<Vec<String>>,
+  pub layer: Option<String>,
 }
 
 impl From<RawOptimizeSharedConfig> for OptimizeSharedConfig {
@@ -234,6 +235,7 @@ impl From<RawOptimizeSharedConfig> for OptimizeSharedConfig {
       share_key: value.share_key,
       tree_shaking: value.tree_shaking,
       used_exports: value.used_exports.unwrap_or_default(),
+      layer: value.layer,
     }
   }
 }
@@ -385,6 +387,7 @@ pub struct RawManifestSharedOption {
   pub name: String,
   pub version: Option<String>,
   pub required_version: Option<String>,
+  pub layer: Option<String>,
   pub singleton: Option<bool>,
 }
 
@@ -453,6 +456,7 @@ impl From<RawModuleFederationManifestPluginOptions> for ModuleFederationManifest
           name: shared.name,
           version: shared.version,
           required_version: shared.required_version,
+          layer: shared.layer,
           singleton: shared.singleton,
         })
         .collect(),

crates/rspack_plugin_mf/src/manifest/data.rs

@@ -50,6 +50,8 @@ pub struct StatsShared {
   pub version: String,
   #[serde(default)]
   pub requiredVersion: Option<String>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub layer: Option<String>,
   #[serde(default)]
   pub singleton: Option<bool>,
   #[serde(default)]
@@ -126,6 +128,8 @@ pub struct ManifestShared {
   pub version: String,
   #[serde(default)]
   pub requiredVersion: Option<String>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub layer: Option<String>,
   #[serde(default)]
   pub singleton: Option<bool>,
   #[serde(default)]

crates/rspack_plugin_mf/src/manifest/mod.rs

@@ -31,8 +31,9 @@ use rspack_hook::{plugin, plugin_hook};
 use rspack_util::fx_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 use utils::{
   collect_entry_files, collect_expose_requirements, compose_id_with_separator,
-  ensure_configured_remotes, ensure_shared_entry, filter_assets, is_hot_file,
-  parse_consume_shared_identifier, parse_provide_shared_identifier, record_shared_usage, strip_ext,
+  compose_shared_map_key, ensure_configured_remotes, ensure_shared_entry, filter_assets,
+  is_hot_file, parse_consume_shared_identifier, parse_provide_shared_identifier,
+  record_shared_usage, strip_ext,
 };
 
 use crate::container::{container_entry_module::ContainerEntryModule, remote_module::RemoteModule};
@@ -183,6 +184,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         name: shared.name.clone(),
         version: shared.version.clone().unwrap_or_default(),
         requiredVersion: shared.required_version.clone(),
+        layer: shared.layer.clone(),
         // default singleton to true when not provided by user
         singleton: shared.singleton.or(Some(true)),
         assets: StatsAssetsGroup::default(),
@@ -232,6 +234,20 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     let mut module_ids_by_name: HashMap<String, ModuleIdentifier> = HashMap::default();
     let mut remote_module_ids: Vec<ModuleIdentifier> = Vec::new();
     let mut container_entry_module: Option<ModuleIdentifier> = None;
+    let find_shared_option = |name: &str, layer: Option<&str>| {
+      self
+        .options
+        .shared
+        .iter()
+        .find(|s| s.name == name && s.layer.as_deref() == layer)
+        .or_else(|| {
+          self
+            .options
+            .shared
+            .iter()
+            .find(|s| s.name == name && s.layer.is_none())
+        })
+    };
     for (_, module) in module_graph.modules() {
       let module_identifier = module.identifier();
       if let Some(path) = module_source_path(module, compilation) {
@@ -322,12 +338,20 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
 
       if matches!(module_type, ModuleType::ProvideShared) {
         if let Some((pkg, ver)) = parse_provide_shared_identifier(&identifier) {
-          let entry = ensure_shared_entry(&mut shared_map, &container_name, &pkg);
+          let layer = module.get_layer().map(ToString::to_string);
+          let shared_key = compose_shared_map_key(&pkg, layer.as_deref());
+          let entry = ensure_shared_entry(
+            &mut shared_map,
+            &shared_key,
+            &container_name,
+            &pkg,
+            layer.clone(),
+          );
           if entry.version.is_empty() {
             entry.version = ver;
           }
           // overlay user-configured shared options (singleton/requiredVersion/version)
-          if let Some(opt) = self.options.shared.iter().find(|s| s.name == pkg) {
+          if let Some(opt) = find_shared_option(&pkg, layer.as_deref()) {
             if let Some(singleton) = opt.singleton {
               entry.singleton = Some(singleton);
             }
@@ -338,7 +362,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
               entry.version = cfg_ver;
             }
           }
-          let targets = shared_module_targets.entry(pkg.clone()).or_default();
+          let targets = shared_module_targets.entry(shared_key.clone()).or_default();
           for connection in module_graph.get_outgoing_connections(&module_identifier) {
             let referenced = *connection.module_identifier();
             if should_collect_module(&referenced) {
@@ -351,7 +375,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
           }
           record_shared_usage(
             &mut shared_usage_links,
-            &pkg,
+            &shared_key,
             &module_identifier,
             module_graph,
             compilation,
@@ -363,6 +387,8 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
       if matches!(module_type, ModuleType::ConsumeShared)
         && let Some((pkg, required)) = parse_consume_shared_identifier(&identifier)
       {
+        let layer = module.get_layer().map(ToString::to_string);
+        let shared_key = compose_shared_map_key(&pkg, layer.as_deref());
         let mut target_ids: IdentifierSet = IdentifierSet::default();
         for connection in module_graph.get_outgoing_connections(&module_identifier) {
           let module_id = *connection.module_identifier();
@@ -375,15 +401,21 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
           }
         }
         shared_module_targets
-          .entry(pkg.clone())
+          .entry(shared_key.clone())
           .or_default()
           .extend(target_ids.into_iter());
-        let entry = ensure_shared_entry(&mut shared_map, &container_name, &pkg);
+        let entry = ensure_shared_entry(
+          &mut shared_map,
+          &shared_key,
+          &container_name,
+          &pkg,
+          layer.clone(),
+        );
         if entry.requiredVersion.is_none() && required.is_some() {
           entry.requiredVersion = required;
         }
         // overlay user-configured shared options
-        if let Some(opt) = self.options.shared.iter().find(|s| s.name == pkg) {
+        if let Some(opt) = find_shared_option(&pkg, layer.as_deref()) {
           if let Some(singleton) = opt.singleton {
             entry.singleton = Some(singleton);
           }
@@ -397,7 +429,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         }
         record_shared_usage(
           &mut shared_usage_links,
-          &pkg,
+          &shared_key,
           &module_identifier,
           module_graph,
           compilation,
@@ -662,6 +694,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         name: s.name,
         version: s.version,
         requiredVersion: s.requiredVersion,
+        layer: s.layer,
         singleton: s.singleton,
         assets: s.assets,
       })

crates/rspack_plugin_mf/src/manifest/options.rs

@@ -19,6 +19,7 @@ pub struct ManifestSharedOption {
   pub name: String,
   pub version: Option<String>,
   pub required_version: Option<String>,
+  pub layer: Option<String>,
   pub singleton: Option<bool>,
 }
 

crates/rspack_plugin_mf/src/manifest/utils.rs

@@ -133,6 +133,13 @@ pub fn compose_id_with_separator(container: &str, name: &str) -> String {
   format!("{container}:{name}")
 }
 
+pub fn compose_shared_map_key(pkg: &str, layer: Option<&str>) -> String {
+  match layer {
+    Some(layer) => format!("{pkg}\u{0000}{layer}"),
+    None => pkg.to_string(),
+  }
+}
+
 pub fn is_hot_file(file: &str) -> bool {
   file.contains(HOT_UPDATE_SUFFIX)
 }
@@ -155,16 +162,22 @@ pub fn strip_ext(path: &str) -> String {
 
 pub fn ensure_shared_entry<'a>(
   shared_map: &'a mut HashMap<String, StatsShared>,
+  shared_key: &str,
   container_name: &str,
   pkg: &str,
+  layer: Option<String>,
 ) -> &'a mut StatsShared {
   shared_map
-    .entry(pkg.to_string())
+    .entry(shared_key.to_string())
     .or_insert_with(|| StatsShared {
-      id: compose_id_with_separator(container_name, pkg),
+      id: match &layer {
+        Some(layer) => compose_id_with_separator(container_name, &format!("{pkg}:{layer}")),
+        None => compose_id_with_separator(container_name, pkg),
+      },
       name: pkg.to_string(),
       version: String::new(),
       requiredVersion: None,
+      layer,
       // default singleton to true
       singleton: Some(true),
       assets: super::data::StatsAssetsGroup::default(),
@@ -175,7 +188,7 @@ pub fn ensure_shared_entry<'a>(
 
 pub fn record_shared_usage(
   shared_usage_links: &mut Vec<(String, String)>,
-  pkg: &str,
+  shared_key: &str,
   module_identifier: &ModuleIdentifier,
   module_graph: &ModuleGraph,
   compilation: &Compilation,
@@ -193,7 +206,7 @@ pub fn record_shared_usage(
       .to_string();
     if !issuer_name.is_empty() {
       let key = strip_ext(&strip_aggregate_suffix(&issuer_name));
-      shared_usage_links.push((pkg.to_string(), key));
+      shared_usage_links.push((shared_key.to_string(), key));
     }
   }
   if let Some(mgm) = module_graph.module_graph_module_by_identifier(module_identifier) {
@@ -212,7 +225,7 @@ pub fn record_shared_usage(
         });
       if let Some(request) = maybe_request {
         let key = strip_ext(&strip_aggregate_suffix(&request));
-        shared_usage_links.push((pkg.to_string(), key));
+        shared_usage_links.push((shared_key.to_string(), key));
       }
     }
   }
@@ -227,7 +240,11 @@ pub fn parse_provide_shared_identifier(identifier: &str) -> Option<(String, Stri
 }
 
 pub fn parse_consume_shared_identifier(identifier: &str) -> Option<(String, Option<String>)> {
-  let (_, rest) = identifier.split_once(") ")?;
+  let (_, mut rest) = identifier.split_once(") ")?;
+  if rest.starts_with('(') {
+    let (_, after_layer) = rest.split_once(") ")?;
+    rest = after_layer;
+  }
   let token = rest.split_whitespace().next()?;
   // For scoped packages like @scope/pkg@1.0.0, split at the LAST '@'
   let (name, version) = token.rsplit_once('@')?;
@@ -247,12 +264,12 @@ pub fn collect_expose_requirements(
   expose_module_paths: &HashMap<String, String>,
 ) {
   #[cfg(debug_assertions)]
-  for (pkg, expose_key) in links {
+  for (shared_key, expose_key) in links {
     if let Some(expose) = exposes_map.get_mut(&expose_key) {
-      if !expose.requires.contains(&pkg) {
-        expose.requires.push(pkg.clone());
-      }
-      if let Some(shared) = shared_map.get_mut(&pkg) {
+      if let Some(shared) = shared_map.get_mut(&shared_key) {
+        if !expose.requires.contains(&shared.name) {
+          expose.requires.push(shared.name.clone());
+        }
         let target = expose_module_paths
           .get(&expose_key)
           .cloned()