feat(mf): layer-aware sharing and runtime scope-array support

crates/node_binding/napi-binding.d.ts

@@ -1941,10 +1941,13 @@ export interface RawCompilerPlatform {
 
 export interface RawConsumeOptions {
   key: string
+  request?: string
+  issuerLayer?: string
+  layer?: string
   import?: string
   importResolved?: string
   shareKey: string
-  shareScope: string | Array<string>
+  shareScope: string | string[]
   requiredVersion?: string | false | undefined
   packageName?: string
   strictVersion: boolean
@@ -1960,7 +1963,7 @@ export interface RawConsumeSharedPluginOptions {
 
 export interface RawContainerPluginOptions {
   name: string
-  shareScope: string | Array<string>
+  shareScope: string | string[]
   library: JsLibraryOptions
   runtime?: false | string
   filename?: string
@@ -1971,7 +1974,7 @@ export interface RawContainerPluginOptions {
 export interface RawContainerReferencePluginOptions {
   remoteType: string
   remotes: Array<RawRemoteOptions>
-  shareScope?: string | Array<string>
+  shareScope?: string | string[] | undefined
   enhanced: boolean
 }
 
@@ -2237,6 +2240,7 @@ export interface RawExperiments {
 export interface RawExposeOptions {
   key: string
   name?: string
+  layer?: string
   import: Array<string>
 }
 
@@ -2787,8 +2791,10 @@ export interface RawProgressPluginOptions {
 
 export interface RawProvideOptions {
   key: string
+  request?: string
+  layer?: string
   shareKey: string
-  shareScope: string | Array<string>
+  shareScope: string | string[]
   version?: string | false | undefined
   eager: boolean
   singleton?: boolean
@@ -2809,7 +2815,7 @@ export interface RawRemoteAliasTarget {
 export interface RawRemoteOptions {
   key: string
   external: Array<string>
-  shareScope: string | Array<string>
+  shareScope: string | string[]
 }
 
 export interface RawResolveOptions {

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

@@ -18,7 +18,9 @@ use crate::options::{
   library::JsLibraryOptions,
 };
 
-fn into_share_scope(value: Either<String, Vec<String>>) -> ShareScope {
+pub type RawShareScope = Either<String, Vec<String>>;
+
+fn into_share_scope(value: RawShareScope) -> ShareScope {
   match value {
     Either::A(s) => ShareScope::Single(s),
     Either::B(list) => ShareScope::Multiple(list),
@@ -29,7 +31,8 @@ fn into_share_scope(value: Either<String, Vec<String>>) -> ShareScope {
 #[napi(object)]
 pub struct RawContainerPluginOptions {
   pub name: String,
-  pub share_scope: Either<String, Vec<String>>,
+  #[napi(ts_type = "string | string[]")]
+  pub share_scope: RawShareScope,
   pub library: JsLibraryOptions,
   #[napi(ts_type = "false | string")]
   pub runtime: Option<JsEntryRuntime>,
@@ -58,6 +61,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 +71,7 @@ impl From<RawExposeOptions> for (String, ExposeOptions) {
       value.key,
       ExposeOptions {
         name: value.name,
+        layer: value.layer,
         import: value.import,
       },
     )
@@ -78,7 +83,8 @@ impl From<RawExposeOptions> for (String, ExposeOptions) {
 pub struct RawContainerReferencePluginOptions {
   pub remote_type: String,
   pub remotes: Vec<RawRemoteOptions>,
-  pub share_scope: Option<Either<String, Vec<String>>>,
+  #[napi(ts_type = "string | string[] | undefined")]
+  pub share_scope: Option<RawShareScope>,
   pub enhanced: bool,
 }
 
@@ -99,7 +105,8 @@ impl From<RawContainerReferencePluginOptions> for ContainerReferencePluginOption
 pub struct RawRemoteOptions {
   pub key: String,
   pub external: Vec<String>,
-  pub share_scope: Either<String, Vec<String>>,
+  #[napi(ts_type = "string | string[]")]
+  pub share_scope: RawShareScope,
 }
 
 impl From<RawRemoteOptions> for (String, RemoteOptions) {
@@ -118,8 +125,11 @@ impl From<RawRemoteOptions> for (String, RemoteOptions) {
 #[napi(object)]
 pub struct RawProvideOptions {
   pub key: String,
+  pub request: Option<String>,
+  pub layer: Option<String>,
   pub share_key: String,
-  pub share_scope: Either<String, Vec<String>>,
+  #[napi(ts_type = "string | string[]")]
+  pub share_scope: RawShareScope,
   #[napi(ts_type = "string | false | undefined")]
   pub version: Option<RawVersion>,
   pub eager: bool,
@@ -135,6 +145,8 @@ impl From<RawProvideOptions> for (String, ProvideOptions) {
     (
       value.key,
       ProvideOptions {
+        request: value.request,
+        layer: value.layer,
         share_key: value.share_key,
         share_scope: into_share_scope(value.share_scope),
         version: value.version.map(|v| RawVersionWrapper(v).into()),
@@ -264,10 +276,14 @@ impl From<RawSharedUsedExportsOptimizerPluginOptions> for SharedUsedExportsOptim
 #[napi(object)]
 pub struct RawConsumeOptions {
   pub key: String,
+  pub request: Option<String>,
+  pub issuer_layer: Option<String>,
+  pub layer: Option<String>,
   pub import: Option<String>,
   pub import_resolved: Option<String>,
   pub share_key: String,
-  pub share_scope: Either<String, Vec<String>>,
+  #[napi(ts_type = "string | string[]")]
+  pub share_scope: RawShareScope,
   #[napi(ts_type = "string | false | undefined")]
   pub required_version: Option<RawVersion>,
   pub package_name: Option<String>,
@@ -282,6 +298,9 @@ impl From<RawConsumeOptions> for (String, ConsumeOptions) {
     (
       value.key,
       ConsumeOptions {
+        request: value.request,
+        issuer_layer: value.issuer_layer,
+        layer: value.layer,
         import: value.import,
         import_resolved: value.import_resolved,
         share_key: value.share_key,

crates/rspack_core/src/stats/mod.rs

@@ -1139,9 +1139,7 @@ impl Stats<'_> {
     options: &ExtendedStatsOptions,
   ) -> Result<StatsModule<'a>> {
     let identifier = module.identifier();
-    let mgm = module_graph
-      .module_graph_module_by_identifier(&identifier)
-      .unwrap_or_else(|| panic!("Could not find ModuleGraphModule by identifier: {identifier:?}"));
+    let mgm = module_graph.module_graph_module_by_identifier(&identifier);
 
     let built = if executed {
       self.module_executor_is_module_built(&identifier)
@@ -1294,7 +1292,7 @@ impl Stats<'_> {
         self
           .build_chunk_graph_artifact()
           .chunk_graph
-          .get_chunk_graph_module(mgm.module_identifier)
+          .get_chunk_graph_module(identifier)
           .map(|cgm| {
             cgm
               .chunks
@@ -1335,8 +1333,8 @@ impl Stats<'_> {
 
     if options.reasons {
       let mut reasons: Vec<StatsModuleReason> = mgm
-        .incoming_connections()
-        .iter()
+        .into_iter()
+        .flat_map(|mgm| mgm.incoming_connections().iter())
         .filter_map(|dep_id| {
           // the connection is removed
           let connection = module_graph.connection_by_dependency_id(dep_id)?;
@@ -1447,13 +1445,17 @@ impl Stats<'_> {
     if options.optimization_bailout {
       stats.optimization_bailout = Some(
         mgm
-          .optimization_bailout
-          .iter()
-          .map(|b| match b {
-            OptimizationBailoutItem::Message(msg) => Cow::Borrowed(msg.as_str()),
-            b => Cow::Owned(b.to_string()),
+          .map(|mgm| {
+            mgm
+              .optimization_bailout
+              .iter()
+              .map(|b| match b {
+                OptimizationBailoutItem::Message(msg) => Cow::Borrowed(msg.as_str()),
+                b => Cow::Owned(b.to_string()),
+              })
+              .collect()
           })
-          .collect(),
+          .unwrap_or_default(),
       );
     }
 

crates/rspack_plugin_mf/src/container/container_entry_module.rs

@@ -215,6 +215,7 @@ impl Module for ContainerEntryModule {
               Box::new(ContainerExposedDependency::new(
                 name.clone(),
                 request.clone(),
+                options.layer.clone(),
               )) as Box<dyn Dependency>
             })
             .collect(),
@@ -397,12 +398,13 @@ var init = function(shareScope, initScope) {{
         has_own_property =
           runtime_template.render_runtime_globals(&RuntimeGlobals::HAS_OWN_PROPERTY),
         share_scope_map = runtime_template.render_runtime_globals(&RuntimeGlobals::SHARE_SCOPE_MAP),
-        share_scope = json_stringify_str(match &self.share_scope {
-          ShareScope::Single(s) => s.as_str(),
-          ShareScope::Multiple(_) => {
-            panic!("ContainerEntryModule: enhanced=false only supports string share scope")
-          }
-        }),
+        share_scope = json_stringify_str(
+          self
+            .share_scope
+            .scopes()
+            .first()
+            .map_or("default", |s| s.as_str())
+        ),
         initialize_sharing =
           runtime_template.render_runtime_globals(&RuntimeGlobals::INITIALIZE_SHARING),
         define_property_getters =

crates/rspack_plugin_mf/src/container/container_exposed_dependency.rs

@@ -1,7 +1,7 @@
 use rspack_cacheable::{cacheable, cacheable_dyn};
 use rspack_core::{
   AsContextDependency, AsDependencyCodeGeneration, Dependency, DependencyCategory, DependencyId,
-  DependencyType, FactorizeInfo, ModuleDependency, ResourceIdentifier,
+  DependencyType, FactorizeInfo, ModuleDependency, ModuleLayer, ResourceIdentifier,
 };
 
 #[cacheable]
@@ -10,18 +10,24 @@ pub struct ContainerExposedDependency {
   id: DependencyId,
   request: String,
   pub exposed_name: String,
+  layer: Option<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 = if let Some(layer) = &layer {
+      format!("exposed dependency {exposed_name}={request}|layer={layer}").into()
+    } else {
+      format!("exposed dependency {exposed_name}={request}").into()
+    };
     Self {
       id: DependencyId::new(),
       request,
       exposed_name,
+      layer,
       resource_identifier,
       dependency_type: DependencyType::ContainerExposed,
       factorize_info: Default::default(),
@@ -34,6 +40,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 +62,10 @@ impl Dependency for ContainerExposedDependency {
     &self.dependency_type
   }
 
+  fn get_layer(&self) -> Option<&ModuleLayer> {
+    self.layer.as_ref()
+  }
+
   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, 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/container/remote_module.rs

@@ -211,12 +211,21 @@ impl Module for RemoteModule {
       )
     });
     codegen.add(SourceType::Remote, RawStringSource::from_static("").boxed());
-    codegen.data.insert(CodeGenerationDataShareInit {
-      items: vec![ShareInitData {
-        share_scope: self.share_scope.clone(),
+    let scopes: Vec<String> = if self.share_scope.is_empty() {
+      vec!["default".to_string()]
+    } else {
+      self.share_scope.scopes().to_vec()
+    };
+    let share_init_items = scopes
+      .iter()
+      .map(|scope| ShareInitData {
+        share_scope: ShareScope::Single(scope.clone()),
         init_stage: 20,
         init: DataInitInfo::ExternalModuleId(id.cloned()),
-      }],
+      })
+      .collect();
+    codegen.data.insert(CodeGenerationDataShareInit {
+      items: share_init_items,
     });
     Ok(codegen)
   }

crates/rspack_plugin_mf/src/manifest/mod.rs

@@ -32,10 +32,13 @@ 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,
+  parse_provide_shared_identifier, record_shared_usage, strip_ext,
 };
 
-use crate::container::{container_entry_module::ContainerEntryModule, remote_module::RemoteModule};
+use crate::{
+  container::{container_entry_module::ContainerEntryModule, remote_module::RemoteModule},
+  sharing::consume_shared_module::ConsumeSharedModule,
+};
 
 #[plugin]
 #[derive(Debug)]
@@ -358,9 +361,21 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         continue;
       }
 
-      if matches!(module_type, ModuleType::ConsumeShared)
-        && let Some((pkg, required)) = parse_consume_shared_identifier(&identifier)
-      {
+      if matches!(module_type, ModuleType::ConsumeShared) {
+        let Some(consume_shared_module) = module
+          .as_ref()
+          .as_any()
+          .downcast_ref::<ConsumeSharedModule>()
+        else {
+          continue;
+        };
+        let pkg = consume_shared_module.share_key().to_string();
+        if pkg.is_empty() {
+          continue;
+        }
+        let required = consume_shared_module
+          .required_version()
+          .map(ToString::to_string);
         let mut target_ids: IdentifierSet = IdentifierSet::default();
         for connection in module_graph.get_outgoing_connections(&module_identifier) {
           let module_id = *connection.module_identifier();