feat(plugin_mf): Module Hoisting, Entry initialization via __webpack_require__.x, Custom Hooks

crates/node_binding/binding.d.ts

@@ -2162,6 +2162,10 @@ export interface RawModuleArg {
   path: string
 }
 
+export interface RawModuleFederationRuntimePluginOptions {
+  entryRuntime?: string | undefined
+}
+
 export interface RawModuleFilenameTemplateFnCtx {
   identifier: string
   shortIdentifier: string

crates/node_binding/src/raw_options/raw_builtins/mod.rs

@@ -27,6 +27,7 @@ use napi_derive::napi;
 use raw_dll::{RawDllReferenceAgencyPluginOptions, RawFlagAllModulesAsUsedPluginOptions};
 use raw_ids::RawOccurrenceChunkIdsPluginOptions;
 use raw_lightning_css_minimizer::RawLightningCssMinimizerRspackPluginOptions;
+use raw_mf::RawModuleFederationRuntimePluginOptions;
 use raw_sri::RawSubresourceIntegrityPluginOptions;
 use rspack_core::{BoxPlugin, Plugin, PluginExt};
 use rspack_error::{Result, ToStringResultToRspackResultExt};
@@ -426,7 +427,9 @@ impl<'a> BuiltinPlugin<'a> {
         .boxed(),
       ),
       BuiltinPluginName::ModuleFederationRuntimePlugin => {
-        plugins.push(ModuleFederationRuntimePlugin::default().boxed())
+        let options = downcast_into::<RawModuleFederationRuntimePluginOptions>(self.options)
+          .map_err(|report| napi::Error::from_reason(report.to_string()))?;
+        plugins.push(ModuleFederationRuntimePlugin::new(options.into()).boxed())
       }
       BuiltinPluginName::NamedModuleIdsPlugin => {
         plugins.push(NamedModuleIdsPlugin::default().boxed())

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

@@ -4,7 +4,8 @@ use napi::Either;
 use napi_derive::napi;
 use rspack_plugin_mf::{
   ConsumeOptions, ConsumeSharedPluginOptions, ConsumeVersion, ContainerPluginOptions,
-  ContainerReferencePluginOptions, ExposeOptions, ProvideOptions, ProvideVersion, RemoteOptions,
+  ContainerReferencePluginOptions, ExposeOptions, ModuleFederationRuntimePluginOptions,
+  ProvideOptions, ProvideVersion, RemoteOptions,
 };
 
 use crate::{
@@ -208,3 +209,18 @@ impl From<RawVersionWrapper> for ConsumeVersion {
     }
   }
 }
+
+#[derive(Debug)]
+#[napi(object)]
+pub struct RawModuleFederationRuntimePluginOptions {
+  #[napi(ts_type = "string | undefined")]
+  pub entry_runtime: Option<String>,
+}
+
+impl From<RawModuleFederationRuntimePluginOptions> for ModuleFederationRuntimePluginOptions {
+  fn from(value: RawModuleFederationRuntimePluginOptions) -> Self {
+    Self {
+      entry_runtime: value.entry_runtime,
+    }
+  }
+}

crates/rspack_plugin_mf/Cargo.toml

@@ -8,15 +8,17 @@ version           = "0.2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rspack_cacheable      = { workspace = true }
-rspack_collections    = { workspace = true }
-rspack_core           = { workspace = true }
-rspack_error          = { workspace = true }
-rspack_hash           = { workspace = true }
-rspack_hook           = { workspace = true }
-rspack_loader_runner  = { workspace = true }
-rspack_plugin_runtime = { workspace = true }
-rspack_util           = { workspace = true }
+rspack_cacheable         = { workspace = true }
+rspack_collections       = { workspace = true }
+rspack_core              = { workspace = true }
+rspack_error             = { workspace = true }
+rspack_hash              = { workspace = true }
+rspack_hook              = { workspace = true }
+rspack_loader_runner     = { workspace = true }
+rspack_plugin_javascript = { workspace = true }
+rspack_plugin_runtime    = { workspace = true }
+rspack_sources           = { workspace = true }
+rspack_util              = { workspace = true }
 
 async-trait = { workspace = true }
 hashlink    = { workspace = true }

crates/rspack_plugin_mf/src/container/container_plugin.rs

@@ -13,7 +13,7 @@ use serde::Serialize;
 use super::{
   container_entry_dependency::ContainerEntryDependency,
   container_entry_module_factory::ContainerEntryModuleFactory,
-  expose_runtime_module::ExposeRuntimeModule,
+  expose_runtime_module::ExposeRuntimeModule, federation_modules_plugin::FederationModulesPlugin,
 };
 
 #[derive(Debug)]
@@ -71,6 +71,16 @@ async fn make(&self, compilation: &mut Compilation) -> Result<()> {
     self.options.share_scope.clone(),
     self.options.enhanced,
   );
+
+  // Call federation hook for dependency tracking
+  let hooks = FederationModulesPlugin::get_compilation_hooks(compilation);
+  hooks
+    .add_container_entry_dependency
+    .lock()
+    .await
+    .call(&dep)
+    .await?;
+
   compilation
     .add_entry(
       Box::new(dep),

crates/rspack_plugin_mf/src/container/embed_federation_runtime_module.rs

@@ -0,0 +1,109 @@
+//! # EmbedFederationRuntimeModule
+//!
+//! Runtime module that wraps the startup function to ensure federation runtime dependencies
+//! execute before other modules. Generates an "oldStartup wrapper" pattern that intercepts
+//! and modifies the startup execution order.
+
+use rspack_cacheable::cacheable;
+use rspack_collections::Identifier;
+use rspack_core::{
+  impl_runtime_module, module_raw, ChunkUkey, Compilation, DependencyId, RuntimeGlobals,
+  RuntimeModule, RuntimeModuleStage,
+};
+use rspack_error::Result;
+
+#[cacheable]
+#[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
+pub struct EmbedFederationRuntimeModuleOptions {
+  pub collected_dependency_ids: Vec<DependencyId>,
+}
+
+#[impl_runtime_module]
+#[derive(Debug)]
+pub struct EmbedFederationRuntimeModule {
+  id: Identifier,
+  chunk: Option<ChunkUkey>,
+  options: EmbedFederationRuntimeModuleOptions,
+}
+
+impl EmbedFederationRuntimeModule {
+  pub fn new(options: EmbedFederationRuntimeModuleOptions) -> Self {
+    Self::with_default(
+      Identifier::from("webpack/runtime/embed_federation_runtime"),
+      None,
+      options,
+    )
+  }
+}
+
+#[async_trait::async_trait]
+impl RuntimeModule for EmbedFederationRuntimeModule {
+  fn name(&self) -> Identifier {
+    self.id
+  }
+
+  async fn generate(&self, compilation: &Compilation) -> Result<String> {
+    let chunk_ukey = self
+      .chunk
+      .expect("Chunk should be attached to RuntimeModule");
+
+    let collected_deps = &self.options.collected_dependency_ids;
+
+    if collected_deps.is_empty() {
+      return Ok("// No federation runtime dependencies to embed.".to_string());
+    }
+
+    let module_graph = compilation.get_module_graph();
+    let mut federation_runtime_modules = Vec::new();
+
+    // Find federation runtime dependencies in this chunk
+    for dep_id in collected_deps.iter() {
+      if let Some(module_dyn) = module_graph.get_module_by_dependency_id(dep_id) {
+        let is_in_chunk = compilation
+          .chunk_graph
+          .is_module_in_chunk(&module_dyn.identifier(), chunk_ukey);
+        if is_in_chunk {
+          federation_runtime_modules.push(*dep_id);
+        }
+      }
+    }
+
+    if federation_runtime_modules.is_empty() {
+      return Ok("// Federation runtime entry modules not found in this chunk.".to_string());
+    }
+
+    // Generate module execution code for each federation runtime dependency
+    let mut runtime_requirements = RuntimeGlobals::default();
+    let mut module_executions = Vec::new();
+
+    for dep_id in federation_runtime_modules {
+      let module_str = module_raw(compilation, &mut runtime_requirements, &dep_id, "", false);
+      module_executions.push(format!("\t\t{}", module_str));
+    }
+
+    // Generate oldStartup wrapper pattern
+    let result = format!(
+      r#"var oldStartup = {startup};
+var hasRun = false;
+{startup} = function() {{
+	if (!hasRun) {{
+		hasRun = true;
+{module_executions}
+	}}
+	return oldStartup();
+}};"#,
+      startup = RuntimeGlobals::STARTUP.name(),
+      module_executions = module_executions.join("\n")
+    );
+
+    Ok(result)
+  }
+
+  fn attach(&mut self, chunk: ChunkUkey) {
+    self.chunk = Some(chunk);
+  }
+
+  fn stage(&self) -> RuntimeModuleStage {
+    RuntimeModuleStage::from(11) // Run after RemoteRuntimeModule (stage 10)
+  }
+}