feat(mf): support layered container exposes

crates/node_binding/napi-binding.d.ts

@@ -2302,6 +2302,7 @@ export interface RawExperiments {
 export interface RawExposeOptions {
   key: string
   name?: string
+  layer?: string
   import: Array<string>
 }
 

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

@@ -58,6 +58,7 @@ impl From<RawContainerPluginOptions> for ContainerPluginOptions {
 pub struct RawExposeOptions {
   pub key: String,
   pub name: Option<String>,
+  pub layer: Option<String>,
   pub import: Vec<String>,
 }
 
@@ -67,6 +68,7 @@ impl From<RawExposeOptions> for (String, ExposeOptions) {
       value.key,
       ExposeOptions {
         name: value.name,
+        layer: value.layer,
         import: value.import,
       },
     )

crates/rspack_plugin_mf/src/container/container_entry_module.rs

@@ -242,6 +242,7 @@ impl Module for ContainerEntryModule {
               Box::new(ContainerExposedDependency::new(
                 name.clone(),
                 request.clone(),
+                options.layer.clone(),
               )) as Box<dyn Dependency>
             })
             .collect(),

crates/rspack_plugin_mf/src/container/container_exposed_dependency.rs

@@ -1,27 +1,45 @@
 use rspack_cacheable::{cacheable, cacheable_dyn};
 use rspack_core::{
   AsContextDependency, AsDependencyCodeGeneration, Dependency, DependencyCategory, DependencyId,
-  DependencyType, FactorizeInfo, ModuleDependency, ResourceIdentifier,
+  DependencyType, FactorizeInfo, ModuleDependency, ModuleLayer, ResourceIdentifier,
 };
 
+use crate::push_identifier_component;
+
+fn exposed_resource_identifier(exposed_name: &str, request: &str, layer: Option<&str>) -> String {
+  let mut resource_identifier = String::from("exposed dependency ");
+  push_identifier_component(&mut resource_identifier, exposed_name);
+  push_identifier_component(&mut resource_identifier, request);
+  if let Some(layer) = layer {
+    resource_identifier.push('1');
+    push_identifier_component(&mut resource_identifier, layer);
+  } else {
+    resource_identifier.push('0');
+  }
+  resource_identifier
+}
+
 #[cacheable]
 #[derive(Debug, Clone)]
 pub struct ContainerExposedDependency {
   id: DependencyId,
   request: String,
   pub exposed_name: String,
+  layer: Option<Box<ModuleLayer>>,
   resource_identifier: ResourceIdentifier,
   dependency_type: DependencyType,
   factorize_info: FactorizeInfo,
 }
 
 impl ContainerExposedDependency {
-  pub fn new(exposed_name: String, request: String) -> Self {
-    let resource_identifier = format!("exposed dependency {exposed_name}={request}").into();
+  pub fn new(exposed_name: String, request: String, layer: Option<ModuleLayer>) -> Self {
+    let resource_identifier =
+      exposed_resource_identifier(&exposed_name, &request, layer.as_deref()).into();
     Self {
       id: DependencyId::new(),
       request,
       exposed_name,
+      layer: layer.map(Box::new),
       resource_identifier,
       dependency_type: DependencyType::ContainerExposed,
       factorize_info: Default::default(),
@@ -34,6 +52,7 @@ impl ContainerExposedDependency {
       id: DependencyId::new(),
       request,
       exposed_name: String::new(),
+      layer: None,
       resource_identifier,
       dependency_type: DependencyType::ShareContainerFallback,
       factorize_info: Default::default(),
@@ -55,6 +74,10 @@ impl Dependency for ContainerExposedDependency {
     &self.dependency_type
   }
 
+  fn get_layer(&self) -> Option<&ModuleLayer> {
+    self.layer.as_deref()
+  }
+
   fn resource_identifier(&self) -> Option<&str> {
     Some(&self.resource_identifier)
   }
@@ -85,3 +108,15 @@ impl ModuleDependency for ContainerExposedDependency {
 
 impl AsContextDependency for ContainerExposedDependency {}
 impl AsDependencyCodeGeneration for ContainerExposedDependency {}
+
+#[cfg(test)]
+mod tests {
+  use super::exposed_resource_identifier;
+
+  #[test]
+  fn exposed_resource_identifiers_are_collision_free() {
+    let first = exposed_resource_identifier("./a", "b=c|layer=foo", None);
+    let second = exposed_resource_identifier("./a=b", "c", Some("foo"));
+    assert_ne!(first, second);
+  }
+}

crates/rspack_plugin_mf/src/container/container_plugin.rs

@@ -3,8 +3,8 @@ use std::sync::Arc;
 use rspack_core::{
   ChunkUkey, Compilation, CompilationAdditionalTreeRuntimeRequirements, CompilationParams,
   CompilationRuntimeRequirementInTree, CompilerCompilation, CompilerMake, DependencyType,
-  EntryOptions, EntryRuntime, Filename, LibraryOptions, Plugin, RuntimeGlobals, RuntimeModule,
-  SourceType,
+  EntryOptions, EntryRuntime, Filename, LibraryOptions, ModuleLayer, Plugin, RuntimeGlobals,
+  RuntimeModule, SourceType,
 };
 use rspack_error::Result;
 use rspack_hook::{plugin, plugin_hook};
@@ -32,6 +32,7 @@ pub struct ContainerPluginOptions {
 #[derive(Debug, Clone, Serialize)]
 pub struct ExposeOptions {
   pub name: Option<String>,
+  pub layer: Option<ModuleLayer>,
   pub import: Vec<String>,
 }
 

crates/rspack_plugin_mf/src/manifest/asset.rs

@@ -126,13 +126,13 @@ pub fn empty_assets_group() -> StatsAssetsGroup {
 }
 
 pub fn normalize_assets_group(group: &mut StatsAssetsGroup) {
-  group.js.sync.sort();
+  group.js.sync.sort_unstable();
   group.js.sync.dedup();
-  group.js.r#async.sort();
+  group.js.r#async.sort_unstable();
   group.js.r#async.dedup();
-  group.css.sync.sort();
+  group.css.sync.sort_unstable();
   group.css.sync.dedup();
-  group.css.r#async.sort();
+  group.css.r#async.sort_unstable();
   group.css.r#async.dedup();
 }
 
@@ -183,7 +183,7 @@ pub fn collect_usage_files_for_module(
     }
   }
   let mut collected: Vec<String> = files.into_iter().collect();
-  collected.sort();
+  collected.sort_unstable();
   collected
 }
 

crates/rspack_plugin_mf/src/manifest/data.rs

@@ -1,22 +1,22 @@
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 
-#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+#[derive(Debug, Serialize, Clone, Default)]
 pub struct StatsAssetsGroup {
   #[serde(default)]
   pub js: AssetsSplit,
   #[serde(default)]
   pub css: AssetsSplit,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+#[derive(Debug, Serialize, Clone, Default)]
 pub struct AssetsSplit {
   #[serde(default)]
   pub sync: Vec<String>,
   #[serde(default)]
   pub r#async: Vec<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+#[derive(Debug, Serialize, Clone, Default)]
 pub struct StatsBuildInfo {
   #[serde(rename = "buildVersion")]
   pub build_version: String,
@@ -28,7 +28,7 @@ pub struct StatsBuildInfo {
   pub plugins: Option<Vec<String>>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Clone)]
 pub struct StatsExpose {
   pub path: String,
   #[serde(default)]
@@ -41,7 +41,7 @@ pub struct StatsExpose {
   pub assets: StatsAssetsGroup,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Clone)]
 pub struct StatsShared {
   pub id: String,
   pub name: String,
@@ -58,7 +58,7 @@ pub struct StatsShared {
   pub usedExports: Vec<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Clone)]
 pub struct StatsRemote {
   pub alias: String,
   pub consumingFederationContainerName: String,
@@ -70,7 +70,7 @@ pub struct StatsRemote {
   pub usedIn: Vec<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Clone)]
 pub struct BasicStatsMetaData {
   pub name: String,
   pub globalName: String,
@@ -84,7 +84,7 @@ pub struct BasicStatsMetaData {
   pub r#type: Option<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+#[derive(Debug, Serialize, Clone, Default)]
 pub struct RemoteEntryMeta {
   #[serde(default)]
   pub name: String,
@@ -94,7 +94,7 @@ pub struct RemoteEntryMeta {
   pub r#type: String,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Clone)]
 pub struct StatsRoot {
   pub id: String,
   pub name: String,

crates/rspack_plugin_mf/src/manifest/mod.rs

@@ -689,7 +689,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     let shared = shared_map
       .into_values()
       .map(|mut v| {
-        v.usedIn.sort();
+        v.usedIn.sort_unstable();
         v.usedIn.dedup();
         v
       })

crates/rspack_plugin_mf/src/sharing/collect_shared_entry_plugin.rs

@@ -211,7 +211,7 @@ async fn finish_make(&self, compilation: &mut Compilation) -> Result<()> {
         }
       }
     }
-    reqs.sort_by(|a, b| a[0].cmp(&b[0]).then(a[1].cmp(&b[1])));
+    reqs.sort_unstable_by(|a, b| a[0].cmp(&b[0]).then(a[1].cmp(&b[1])));
     ordered_requests.insert(identity, reqs);
   }
 

crates/rspack_plugin_mf/src/sharing/shared_used_exports_optimizer_plugin.rs

@@ -16,16 +16,14 @@ use rspack_hook::{plugin, plugin_hook};
 use rspack_plugin_javascript::dependency::{ESMImportSpecifierDependency, ImportDependency};
 use rspack_util::atom::Atom;
 use rustc_hash::{FxHashMap, FxHashSet};
+use serde_json::Value;
 
 use super::{
   RequestMatchKey, consume_shared_module::ConsumeSharedModule, find_exact_match,
   provide_shared_module::ProvideSharedModule,
   shared_used_exports_optimizer_runtime_module::SharedUsedExportsOptimizerRuntimeModule,
 };
-use crate::{
-  ShareScope, SharedIdentity, container::container_entry_module::ContainerEntryModule,
-  manifest::StatsRoot,
-};
+use crate::{ShareScope, SharedIdentity, container::container_entry_module::ContainerEntryModule};
 
 fn shared_identity_from_output(
   share_key: &str,
@@ -52,6 +50,27 @@ fn referenced_exports_for_output<'a>(
   matching.next().is_none().then_some(exports)
 }
 
+fn update_shared_exports(
+  content: &str,
+  shared_referenced_exports: &FxHashMap<SharedIdentity, FxHashSet<String>>,
+) -> Option<String> {
+  let mut root = serde_json::from_str::<Value>(content).ok()?;
+  for shared in root.get_mut("shared")?.as_array_mut()? {
+    let share_key = shared.get("name")?.as_str()?;
+    let Some(exports_set) = referenced_exports_for_output(shared_referenced_exports, share_key)
+    else {
+      continue;
+    };
+    let mut exports = exports_set.iter().cloned().collect::<Vec<_>>();
+    exports.sort_unstable();
+    shared.as_object_mut()?.insert(
+      "usedExports".to_string(),
+      Value::Array(exports.into_iter().map(Value::String).collect()),
+    );
+  }
+  serde_json::to_string_pretty(&root).ok()
+}
+
 #[derive(Debug, Clone)]
 pub struct OptimizeSharedConfig {
   pub request: String,
@@ -336,18 +355,8 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
       && let Some(file) = compilation.assets().get(file_name)
       && let Some(source) = file.get_source()
       && let SourceValue::String(content) = source.source()
-      && let Ok(mut stats_root) = serde_json::from_str::<StatsRoot>(&content)
+      && let Some(updated_content) = update_shared_exports(&content, &shared_referenced_exports)
     {
-      for shared in &mut stats_root.shared {
-        if let Some(exports_set) =
-          referenced_exports_for_output(&shared_referenced_exports, &shared.name)
-        {
-          shared.usedExports = exports_set.iter().cloned().collect::<Vec<_>>();
-          shared.usedExports.sort();
-        }
-      }
-      let updated_content = serde_json::to_string_pretty(&stats_root)
-        .map_err(|e| rspack_error::error!("Failed to serialize stats root: {}", e))?;
       compilation.update_asset(file_name, |_, info| {
         Ok((RawStringSource::from(updated_content).boxed(), info))
       })?;
@@ -532,10 +541,27 @@ mod tests {
 
   use super::{
     OptimizeSharedConfig, SharedUsedExportsOptimizerPlugin,
-    SharedUsedExportsOptimizerPluginOptions, referenced_exports_for_output,
+    SharedUsedExportsOptimizerPluginOptions, referenced_exports_for_output, update_shared_exports,
   };
   use crate::{ShareScope, SharedIdentity};
 
+  #[test]
+  fn updates_shared_exports_without_typed_deserialization() {
+    let identity = SharedIdentity::new(&ShareScope::Single("default".to_string()), "pkg", None);
+    let mut referenced_exports = FxHashMap::default();
+    referenced_exports.insert(
+      identity,
+      FxHashSet::from_iter(["named".to_string(), "default".to_string()]),
+    );
+    let content = r#"{"shared":[{"name":"pkg"}]}"#;
+
+    let updated = update_shared_exports(content, &referenced_exports).expect("updated");
+    let updated: serde_json::Value = serde_json::from_str(&updated).expect("valid json");
+    assert_eq!(
+      updated["shared"][0]["usedExports"],
+      serde_json::json!(["default", "named"])
+    );
+  }
   #[test]
   fn optimizer_keeps_same_key_and_layer_separate_by_scope() {
     let plugin = SharedUsedExportsOptimizerPlugin::new(SharedUsedExportsOptimizerPluginOptions {

crates/rspack_plugin_mf/src/sharing/shared_used_exports_optimizer_runtime_module.rs

@@ -38,7 +38,7 @@ impl SharedUsedExportsOptimizerRuntimeModule {
         .iter()
         .map(|(share_key, set)| {
           let mut exports: Vec<String> = set.iter().cloned().collect();
-          exports.sort();
+          exports.sort_unstable();
           (share_key.clone(), exports)
         })
         .collect();