feat(mf): support layered container exposes

crates/node_binding/napi-binding.d.ts

@@ -2365,6 +2365,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/mod.rs

@@ -524,14 +524,10 @@ impl<'a> BuiltinPlugin<'a> {
         plugins.push(SharedUsedExportsOptimizerPlugin::new_enhanced(options).boxed());
       }
       BuiltinPluginName::ContainerPlugin => {
-        plugins.push(
-          ContainerPlugin::new(
-            downcast_into::<RawContainerPluginOptions>(self.options)
-              .map_err(|report| napi::Error::from_reason(report.to_string()))?
-              .into(),
-          )
-          .boxed(),
-        );
+        let options = downcast_into::<RawContainerPluginOptions>(self.options)
+          .map_err(|report| napi::Error::from_reason(report.to_string()))?
+          .into_options();
+        plugins.push(ContainerPlugin::new_enhanced(options).boxed());
       }
       BuiltinPluginName::ContainerReferencePlugin => {
         plugins.push(

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

@@ -3,11 +3,11 @@ use std::sync::Arc;
 use napi::Either;
 use napi_derive::napi;
 use rspack_plugin_mf::{
-  ConsumeVersion, ContainerPluginOptions, ContainerReferencePluginOptions,
-  EnhancedCollectSharedEntryPluginOptions, EnhancedConsumeOptions,
-  EnhancedConsumeSharedPluginOptions, EnhancedOptimizeSharedConfig, EnhancedProvideOptions,
+  ConsumeVersion, ContainerReferencePluginOptions, EnhancedCollectSharedEntryPluginOptions,
+  EnhancedConsumeOptions, EnhancedConsumeSharedPluginOptions, EnhancedContainerPluginOptions,
+  EnhancedExposeOptions, EnhancedOptimizeSharedConfig, EnhancedProvideOptions,
   EnhancedSharedContainerPluginOptions, EnhancedSharedUsedExportsOptimizerPluginOptions,
-  ExposeOptions, ManifestExposeOption, ManifestSharedOption, ModuleFederationManifestPluginOptions,
+  ManifestExposeOption, ManifestSharedOption, ModuleFederationManifestPluginOptions,
   ModuleFederationRuntimeExperimentsOptions, ModuleFederationRuntimePluginOptions, ProvideVersion,
   RemoteAliasTarget, RemoteOptions, ShareScope, StatsBuildInfo,
 };
@@ -38,17 +38,17 @@ pub struct RawContainerPluginOptions {
   pub enhanced: bool,
 }
 
-impl From<RawContainerPluginOptions> for ContainerPluginOptions {
-  fn from(value: RawContainerPluginOptions) -> Self {
-    let share_scope = into_share_scope(value.share_scope);
-    Self {
-      name: value.name,
+impl RawContainerPluginOptions {
+  pub fn into_options(self) -> EnhancedContainerPluginOptions {
+    let share_scope = into_share_scope(self.share_scope);
+    EnhancedContainerPluginOptions {
+      name: self.name,
       share_scope,
-      library: value.library.into(),
-      runtime: value.runtime.map(|r| JsEntryRuntimeWrapper(r).into()),
-      filename: value.filename.map(|f| f.into()),
-      exposes: value.exposes.into_iter().map(|e| e.into()).collect(),
-      enhanced: value.enhanced,
+      library: self.library.into(),
+      runtime: self.runtime.map(|r| JsEntryRuntimeWrapper(r).into()),
+      filename: self.filename.map(|f| f.into()),
+      exposes: self.exposes.into_iter().map(|e| e.into()).collect(),
+      enhanced: self.enhanced,
     }
   }
 }
@@ -58,16 +58,18 @@ impl From<RawContainerPluginOptions> for ContainerPluginOptions {
 pub struct RawExposeOptions {
   pub key: String,
   pub name: Option<String>,
+  pub layer: Option<String>,
   pub import: Vec<String>,
 }
 
-impl From<RawExposeOptions> for (String, ExposeOptions) {
+impl From<RawExposeOptions> for (String, EnhancedExposeOptions) {
   fn from(value: RawExposeOptions) -> Self {
     (
       value.key,
-      ExposeOptions {
+      EnhancedExposeOptions {
         name: value.name,
         import: value.import,
+        layer: value.layer,
       },
     )
   }

crates/rspack_plugin_mf/src/container/container_entry_dependency.rs

@@ -4,14 +4,14 @@ use rspack_core::{
   DependencyType, ModuleDependency, ResourceIdentifier,
 };
 
-use crate::{ExposeOptions, ShareScope, SharedIdentity};
+use crate::{EnhancedExposeOptions, ShareScope, SharedIdentity};
 
 #[cacheable]
 #[derive(Debug)]
 pub struct ContainerEntryDependency {
   id: DependencyId,
   pub name: String,
-  pub exposes: Vec<(String, ExposeOptions)>,
+  pub exposes: Vec<(String, EnhancedExposeOptions)>,
   pub share_scope: ShareScope,
   pub request: Option<String>,
   pub version: Option<String>,
@@ -25,7 +25,7 @@ pub struct ContainerEntryDependency {
 impl ContainerEntryDependency {
   pub fn new(
     name: String,
-    exposes: Vec<(String, ExposeOptions)>,
+    exposes: Vec<(String, EnhancedExposeOptions)>,
     share_scope: ShareScope,
     enhanced: bool,
   ) -> Self {

crates/rspack_plugin_mf/src/container/container_entry_module.rs

@@ -20,7 +20,7 @@ use rspack_hash::{RspackHashDigest, RspackHasher};
 use rspack_util::{json_stringify_str, source_map::SourceMapKind};
 
 use super::{
-  container_exposed_dependency::ContainerExposedDependency, container_plugin::ExposeOptions,
+  container_exposed_dependency::ContainerExposedDependency, container_plugin::EnhancedExposeOptions,
 };
 use crate::{
   ShareScope, SharedIdentity, push_identifier_component,
@@ -34,7 +34,7 @@ pub struct ContainerEntryModule {
   dependencies_block: DependenciesBlockData,
   identifier: ModuleIdentifier,
   lib_ident: String,
-  exposes: Vec<(String, ExposeOptions)>,
+  exposes: Vec<(String, EnhancedExposeOptions)>,
   share_scope: ShareScope,
   factory_meta: FactoryMetaStore,
   build_info: FreezeLock<BuildInfo>,
@@ -51,7 +51,7 @@ pub struct ContainerEntryModule {
 impl ContainerEntryModule {
   pub fn new(
     name: String,
-    exposes: Vec<(String, ExposeOptions)>,
+    exposes: Vec<(String, EnhancedExposeOptions)>,
     share_scope: ShareScope,
     enhanced: bool,
     runtime_mode: RuntimeMode,
@@ -63,6 +63,9 @@ impl ContainerEntryModule {
       identifier: ModuleIdentifier::from(format!(
         "container entry {} {}",
         share_scope.identifier_fragment(),
+        // Same `[[key, options]]` payload as webpack's ContainerEntryModule,
+        // which external manifest readers parse; `EnhancedExposeOptions::layer` is
+        // serialized only when present.
         json_stringify(&exposes),
       )),
       lib_ident,
@@ -134,7 +137,7 @@ impl ContainerEntryModule {
     }
   }
 
-  pub fn exposes(&self) -> &[(String, ExposeOptions)] {
+  pub fn exposes(&self) -> &[(String, EnhancedExposeOptions)] {
     &self.exposes
   }
 
@@ -235,9 +238,10 @@ impl Module for ContainerEntryModule {
             .import
             .iter()
             .map(|request| {
-              BoxDependency::new(ContainerExposedDependency::new(
+              BoxDependency::new(ContainerExposedDependency::new_with_layer(
                 name.clone(),
                 request.clone(),
+                options.layer.clone(),
               ))
             })
             .collect(),

crates/rspack_plugin_mf/src/container/container_exposed_dependency.rs

@@ -1,26 +1,48 @@
 use rspack_cacheable::{cacheable, cacheable_dyn};
 use rspack_core::{
   AsContextDependency, AsDependencyCodeGeneration, Dependency, DependencyCategory, DependencyId,
-  DependencyType, ModuleDependency, ResourceIdentifier,
+  DependencyType, 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)]
 pub struct ContainerExposedDependency {
   id: DependencyId,
   request: String,
   pub exposed_name: String,
+  layer: Option<Box<ModuleLayer>>,
   resource_identifier: ResourceIdentifier,
   dependency_type: DependencyType,
 }
 
 impl ContainerExposedDependency {
   pub fn new(exposed_name: String, request: String) -> Self {
-    let resource_identifier = format!("exposed dependency {exposed_name}={request}").into();
+    Self::new_with_layer(exposed_name, request, None)
+  }
+
+  pub fn new_with_layer(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,
     }
@@ -32,6 +54,7 @@ impl ContainerExposedDependency {
       id: DependencyId::new(),
       request,
       exposed_name: String::new(),
+      layer: None,
       resource_identifier,
       dependency_type: DependencyType::ShareContainerFallback,
     }
@@ -52,6 +75,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)
   }

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, DependencyRef,
-  DependencyType, EntryOptions, EntryRuntime, Filename, LibraryOptions, Plugin, RuntimeGlobals,
-  RuntimeModule, SourceType,
+  DependencyType, EntryOptions, EntryRuntime, Filename, LibraryOptions, ModuleLayer, Plugin,
+  RuntimeGlobals, RuntimeModule, SourceType,
 };
 use rspack_error::Result;
 use rspack_hook::{plugin, plugin_hook};
@@ -17,6 +17,13 @@ use super::{
 };
 use crate::ShareScope;
 
+#[rspack_cacheable::cacheable]
+#[derive(Debug, Clone, Serialize)]
+pub struct ExposeOptions {
+  pub name: Option<String>,
+  pub import: Vec<String>,
+}
+
 #[derive(Debug)]
 pub struct ContainerPluginOptions {
   pub name: String,
@@ -28,21 +35,70 @@ pub struct ContainerPluginOptions {
   pub enhanced: bool,
 }
 
+impl From<ExposeOptions> for EnhancedExposeOptions {
+  fn from(value: ExposeOptions) -> Self {
+    Self {
+      name: value.name,
+      import: value.import,
+      layer: None,
+    }
+  }
+}
+
+impl From<ContainerPluginOptions> for EnhancedContainerPluginOptions {
+  fn from(value: ContainerPluginOptions) -> Self {
+    Self {
+      name: value.name,
+      share_scope: value.share_scope,
+      library: value.library,
+      runtime: value.runtime,
+      filename: value.filename,
+      exposes: value
+        .exposes
+        .into_iter()
+        .map(|(key, options)| (key, options.into()))
+        .collect(),
+      enhanced: value.enhanced,
+    }
+  }
+}
+
+/// Container configuration with layer-aware exposed modules.
+#[derive(Debug)]
+pub struct EnhancedContainerPluginOptions {
+  pub name: String,
+  pub share_scope: ShareScope,
+  pub library: LibraryOptions,
+  pub runtime: Option<EntryRuntime>,
+  pub filename: Option<Filename>,
+  pub exposes: Vec<(String, EnhancedExposeOptions)>,
+  pub enhanced: bool,
+}
+
 #[rspack_cacheable::cacheable]
 #[derive(Debug, Clone, Serialize)]
-pub struct ExposeOptions {
+pub struct EnhancedExposeOptions {
   pub name: Option<String>,
   pub import: Vec<String>,
+  /// Layer the exposed module is built in. Serialized into the container
+  /// identifier only when present so unlayered identifiers keep webpack's
+  /// `[[key, options]]` payload.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub layer: Option<ModuleLayer>,
 }
 
 #[plugin]
 #[derive(Debug)]
 pub struct ContainerPlugin {
-  options: ContainerPluginOptions,
+  options: EnhancedContainerPluginOptions,
 }
 
 impl ContainerPlugin {
   pub fn new(options: ContainerPluginOptions) -> Self {
+    Self::new_enhanced(options.into())
+  }
+
+  pub fn new_enhanced(options: EnhancedContainerPluginOptions) -> Self {
     Self::new_inner(options)
   }
 }

crates/rspack_plugin_mf/src/lib.rs

@@ -111,7 +111,10 @@ impl RspackHash for ShareScope {
 }
 
 pub use container::{
-  container_plugin::{ContainerPlugin, ContainerPluginOptions, ExposeOptions},
+  container_plugin::{
+    ContainerPlugin, ContainerPluginOptions, EnhancedContainerPluginOptions, EnhancedExposeOptions,
+    ExposeOptions,
+  },
   container_reference_plugin::{
     ContainerReferencePlugin, ContainerReferencePluginOptions, RemoteOptions,
   },

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/mod.rs

@@ -721,7 +721,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         if let Some(singleton) = consumed_singletons.get(&v.name) {
           v.singleton = Some(*singleton);
         }
-        v.usedIn.sort();
+        v.usedIn.sort_unstable();
         v.usedIn.dedup();
         v
       })