web-infra-dev
diff --git a/‎Cargo.lock
Lines changed: 2 additions & 0 deletions b/‎Cargo.lock
Lines changed: 2 additions & 0 deletions
diff --git a/‎crates/node_binding/binding.d.ts
Lines changed: 1 addition & 1 deletion b/‎crates/node_binding/binding.d.ts
Lines changed: 1 addition & 1 deletion
diff --git a/‎crates/node_binding/napi-binding.d.ts
Lines changed: 4 additions & 0 deletions b/‎crates/node_binding/napi-binding.d.ts
Lines changed: 4 additions & 0 deletions
diff --git a/‎crates/rspack_binding_api/src/raw_options/raw_builtins/mod.rs
Lines changed: 4 additions & 1 deletion b/‎crates/rspack_binding_api/src/raw_options/raw_builtins/mod.rs
Lines changed: 4 additions & 1 deletion
diff --git a/‎crates/rspack_binding_api/src/raw_options/raw_builtins/raw_mf.rs
Lines changed: 17 additions & 1 deletion b/‎crates/rspack_binding_api/src/raw_options/raw_builtins/raw_mf.rs
Lines changed: 17 additions & 1 deletion
diff --git a/‎crates/rspack_plugin_mf/Cargo.toml
Lines changed: 12 additions & 10 deletions b/‎crates/rspack_plugin_mf/Cargo.toml
Lines changed: 12 additions & 10 deletions
diff --git a/‎crates/rspack_plugin_mf/src/container/container_plugin.rs
Lines changed: 11 additions & 1 deletion b/‎crates/rspack_plugin_mf/src/container/container_plugin.rs
Lines changed: 11 additions & 1 deletion
diff --git a/‎crates/rspack_plugin_mf/src/container/embed_federation_runtime_module.rs
Lines changed: 118 additions & 0 deletions b/‎crates/rspack_plugin_mf/src/container/embed_federation_runtime_module.rs
Lines changed: 118 additions & 0 deletions
@@ -5,4 +5,4 @@
 import * as binding from "./napi-binding";
 
 export * from "./napi-binding"
-export default binding;
+export default binding;
@@ -2220,6 +2220,10 @@ export interface RawModuleArg {
   path: string
 }
 
+export interface RawModuleFederationRuntimePluginOptions {
+  entryRuntime?: string | undefined
+}
+
 export interface RawModuleFilenameTemplateFnCtx {
   identifier: string
   shortIdentifier: string
 
@@ -29,6 +29,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};
@@ -468,7 +469,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())
 
@@ -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,
+    }
+  }
+}
@@ -8,16 +8,18 @@ version.workspace = true
 # 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_fs             = { 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_fs                = { 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 }
 camino      = { workspace = true }
 
@@ -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),
 
@@ -0,0 +1,118 @@
+//! # EmbedFederationRuntimeModule
+//!
+//! Runtime module that wraps the startup function to ensure federation runtime dependencies
+//! execute before other modules. Generates a "prevStartup wrapper" pattern with defensive
+//! checks 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.".into());
+    }
+
+    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.".into());
+    }
+
+    // Generate module execution code for each federation runtime dependency
+    let mut runtime_requirements = RuntimeGlobals::default();
+    let mut module_executions = String::with_capacity(federation_runtime_modules.len() * 50);
+
+    for dep_id in federation_runtime_modules {
+      let module_str = module_raw(compilation, &mut runtime_requirements, &dep_id, "", false);
+      module_executions.push_str("\t\t");
+      module_executions.push_str(&module_str);
+      module_executions.push('\n');
+    }
+    // Remove trailing newline
+    if !module_executions.is_empty() {
+      module_executions.pop();
+    }
+
+    // Generate prevStartup wrapper pattern with defensive checks
+    let startup = RuntimeGlobals::STARTUP.name();
+    let result = format!(
+      r#"var prevStartup = {startup};
+var hasRun = false;
+{startup} = function() {{
+	if (!hasRun) {{
+		hasRun = true;
+{module_executions}
+	}}
+	if (typeof prevStartup === 'function') {{
+		return prevStartup();
+	}} else {{
+		console.warn('[MF] Invalid prevStartup');
+	}}
+}};"#
+    );
+
+    Ok(result)
+  }
+
+  fn attach(&mut self, chunk: ChunkUkey) {
+    self.chunk = Some(chunk);
+  }
+
+  fn stage(&self) -> RuntimeModuleStage {
+    RuntimeModuleStage::from(11) // Run after RemoteRuntimeModule (stage 10)
+  }
+}