@@ -5,8 +5,9 @@ use itertools::Itertools;
 use oxc_index::IndexVec;
 use rolldown_common::{
   Chunk, ChunkDebugInfo, ChunkIdx, ChunkKind, ChunkMeta, ChunkReasonType,
-  FacadeChunkEliminationReason, Module, ModuleIdx, ModuleNamespaceIncludedReason, ModuleTable,
-  PostChunkOptimizationOperation, PreserveEntrySignatures, RuntimeHelper, StmtInfos, WrapKind,
+  FacadeChunkEliminationReason, IdxDebugExt, Module, ModuleIdx, ModuleNamespaceIncludedReason,
+  ModuleTable, PostChunkOptimizationOperation, PreserveEntrySignatures, RuntimeHelper, StmtInfos,
+  WrapKind,
 };
 use rolldown_utils::{BitSet, indexmap::FxIndexMap};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -22,8 +23,10 @@ use crate::{
 };
 
 use super::{
-  GenerateStage, chunk_ext::ChunkCreationReason, chunk_ext::ChunkDebugExt,
-  code_splitting::IndexSplittingInfo,
+  GenerateStage,
+  chunk_ext::ChunkCreationReason,
+  chunk_ext::ChunkDebugExt,
+  code_splitting::{IndexSplittingInfo, PendingCommonChunkInfo},
 };
 
 /// Information about a facade chunk merge operation.
@@ -93,16 +96,40 @@ impl GenerateStage<'_> {
     chunk_graph: &mut ChunkGraph,
     bits_to_chunk: &mut FxHashMap<BitSet, ChunkIdx>,
     input_base: &ArcStr,
-    pending_common_chunks: FxIndexMap<BitSet, Vec<ModuleIdx>>,
+    pending_common_chunks: FxIndexMap<BitSet, PendingCommonChunkInfo>,
   ) {
     let static_entry_chunk_reference: FxHashMap<ChunkIdx, FxHashSet<ChunkIdx>> =
       self.construct_static_entry_to_reached_dynamic_entries_map(chunk_graph);
 
     let entry_chunk_idx =
       chunk_graph.chunk_table.iter_enumerated().map(|(idx, _)| idx).collect::<FxHashSet<_>>();
+    // Calculate on demand to avoid add a new field on each NormalModule.
+    let dynamic_entry_to_dynamic_importers: FxHashMap<ModuleIdx, FxHashSet<ModuleIdx>> = {
+      // Get dynamic entry modules from chunk_table, then find matched entry points
+      // and extract importers from related_stmt_infos
+      let mut map: FxHashMap<ModuleIdx, FxHashSet<ModuleIdx>> = FxHashMap::default();
+      for chunk in chunk_graph.chunk_table.iter() {
+        let ChunkKind::EntryPoint { meta, module, .. } = chunk.kind else {
+          continue;
+        };
+        if meta != ChunkMeta::DynamicImported {
+          continue;
+        }
+        // Find the matched dynamic entry point from link_output.entries
+        if let Some(entries) = self.link_output.entries.get(&module) {
+          for entry in entries.iter().filter(|e| e.kind.is_dynamic_import()) {
+            // Extract importers from related_stmt_infos (first element is the importer ModuleIdx)
+            for (importer_idx, _, _, _) in &entry.related_stmt_infos {
+              map.entry(module).or_default().insert(*importer_idx);
+            }
+          }
+        }
+      }
+      map
+    };
     // extract entry chunk module relation
     // this means `key_chunk` also referenced all entry module in value `vec`
-    for (bits, modules) in pending_common_chunks {
+    for (bits, PendingCommonChunkInfo { modules, meta: _ }) in pending_common_chunks {
       let chunk_idxs = bits
         .index_of_one()
         .into_iter()
@@ -117,6 +144,8 @@ impl GenerateStage<'_> {
         &static_entry_chunk_reference,
         chunk_graph,
         &self.link_output.module_table,
+        &dynamic_entry_to_dynamic_importers,
+        &modules,
       );
 
       self.assign_modules_to_chunk(
@@ -238,6 +267,8 @@ impl GenerateStage<'_> {
     entry_chunk_reference: &FxHashMap<ChunkIdx, FxHashSet<ChunkIdx>>,
     chunk_graph: &ChunkGraph,
     module_table: &ModuleTable,
+    dynamic_entry_to_dynamic_importers: &FxHashMap<ModuleIdx, FxHashSet<ModuleIdx>>,
+    modules: &[ModuleIdx],
   ) -> Option<ChunkIdx> {
     let mut user_defined_entry = vec![];
     let mut dynamic_entry = vec![];
@@ -262,18 +293,33 @@ impl GenerateStage<'_> {
       Self::find_merge_target(&user_defined_entry, &user_defined_entry_modules, module_table);
     if !user_defined_entry.is_empty() {
       let chunk_idx = merged_user_defined_chunk?;
-
-      let ret = dynamic_entry.iter().all(|idx| {
-        entry_chunk_reference
-          .get(&chunk_idx)
-          .map(|reached_dynamic_chunk| reached_dynamic_chunk.contains(idx))
-          .unwrap_or(false)
+      let chunk = &chunk_graph.chunk_table[chunk_idx];
+      let reached_dynamic_chunk = entry_chunk_reference.get(&chunk_idx);
+      // Check if all dynamic entry chunks are reachable from the merged user-defined entry chunk.
+      // If not, we cannot merge the shared modules into the user-defined entry chunk because
+      // the dynamic entries would not be able to access the shared modules.
+      let all_dynamic_entries_reachable =
+        dynamic_entry.iter().all(|idx| reached_dynamic_chunk.is_some_and(|set| set.contains(idx)));
+      if !all_dynamic_entries_reachable {
+        return None;
+      }
+      let merged_entry_module = chunk.entry_module(module_table)?;
+      // For each module in the shared modules, if it is a dynamic entry module,
+      // all its dynamic importers must also statically import the entry module of the merged chunk.
+      // This ensures that when a dynamic import occurs, the merged entry chunk (containing the
+      // dynamic entry module) is already loaded, preventing missing module errors at runtime.
+      let all_dynamic_entry_importers_valid = modules.iter().all(|&module_idx| {
+        let Some(importers) = dynamic_entry_to_dynamic_importers.get(&module_idx) else {
+          // Not a dynamic entry module, no constraint
+          return true;
+        };
+        importers.iter().all(|importer| *importer == merged_entry_module.idx)
       });
-      return ret.then_some(chunk_idx);
+      all_dynamic_entry_importers_valid.then_some(chunk_idx)
+    } else {
+      let dynamic_chunk_entry_modules = Self::collect_entry_modules(&dynamic_entry, chunk_graph)?;
+      Self::find_merge_target(&dynamic_entry, &dynamic_chunk_entry_modules, module_table)
     }
-
-    let dynamic_chunk_entry_modules = Self::collect_entry_modules(&dynamic_entry, chunk_graph)?;
-    Self::find_merge_target(&dynamic_entry, &dynamic_chunk_entry_modules, module_table)
   }
 
   /// Collects entry module indices from a list of chunk indices.
@@ -350,6 +396,7 @@ impl GenerateStage<'_> {
   /// Finds empty dynamic entry chunks that should be merged with their target common chunks.
   /// Returns a tuple of (merge_entry_to_chunk, emitted_chunk_groups).
   fn find_facade_chunk_merge_candidates(
+    &self,
     chunk_graph: &ChunkGraph,
   ) -> (FxHashMap<ModuleIdx, FacadeChunkMergeInfo>, FxHashMap<ChunkIdx, Vec<ChunkIdx>>) {
     let mut merge_entry_to_chunk = FxHashMap::default();
@@ -385,6 +432,9 @@ impl GenerateStage<'_> {
         ChunkReasonType::ManualCodeSplitting { .. }
       );
       let is_pure_user_defined_to_entry_chunk = matches!(target_chunk.kind, ChunkKind::EntryPoint { meta, bit: _, module: _ } if meta.is_pure_user_defined_entry());
+      dbg!(&chunk_idx.debug(&self.link_output.module_table, &chunk_graph.chunk_table));
+      dbg!(&target_chunk_idx.debug(&self.link_output.module_table, &chunk_graph.chunk_table));
+      dbg!(&target_chunk.kind);
       // Three optimization scenarios:
       // 1. Emitted chunk (AllowExtension) merged into manual code splitting group
       //    → Group by target chunk to detect export name conflicts before merging
@@ -477,7 +527,7 @@ impl GenerateStage<'_> {
   ) {
     // Find empty dynamic entry chunks that should be merged with their target common chunks
     let (mut merge_entry_to_chunk, emitted_chunk_groups) =
-      Self::find_facade_chunk_merge_candidates(chunk_graph);
+      self.find_facade_chunk_merge_candidates(chunk_graph);
 
     if merge_entry_to_chunk.is_empty() && emitted_chunk_groups.is_empty() {
       return;
 
@@ -24,6 +24,20 @@ use rustc_hash::{FxHashMap, FxHashSet};
 
 use super::{GenerateStage, chunk_ext::ChunkCreationReason};
 
+bitflags::bitflags! {
+  #[derive(Debug, Clone, Copy, Default)]
+  pub struct PendingCommonChunkMeta: u8 {
+    // Empty for now, will be extended as needed
+  }
+}
+
+#[derive(Debug, Default)]
+pub struct PendingCommonChunkInfo {
+  pub modules: Vec<ModuleIdx>,
+  #[expect(dead_code, reason = "Reserved for future use")]
+  pub meta: PendingCommonChunkMeta,
+}
+
 #[derive(Clone, Debug)]
 pub struct SplittingInfo {
   pub bits: BitSet,
@@ -803,7 +817,8 @@ impl GenerateStage<'_> {
       )
       .await?;
 
-    let mut pending_common_chunks: FxIndexMap<BitSet, Vec<ModuleIdx>> = FxIndexMap::default();
+    let mut pending_common_chunks: FxIndexMap<BitSet, PendingCommonChunkInfo> =
+      FxIndexMap::default();
     // If it is allow to allow that entry chunks have the different exports as the underlying entry module.
     // This is used to generate less chunks when possible.
     // TODO: maybe we could bailout peer chunk?
@@ -838,7 +853,7 @@ impl GenerateStage<'_> {
           self.link_output.metas[normal_module.idx].depended_runtime_helper,
         );
       } else if allow_chunk_optimization {
-        pending_common_chunks.entry(bits.clone()).or_default().push(normal_module.idx);
+        pending_common_chunks.entry(bits.clone()).or_default().modules.push(normal_module.idx);
       } else {
         let mut chunk =
           Chunk::new(None, None, bits.clone(), vec![], ChunkKind::Common, input_base.clone(), None);
 
@@ -0,0 +1,14 @@
+{
+  "config": {
+    "input": [
+      {
+        "name": "main",
+        "import": "./main.js"
+      },
+      {
+        "name": "other",
+        "import": "./other.js"
+      }
+    ]
+  }
+}
@@ -0,0 +1,41 @@
+---
+source: crates/rolldown_testing/src/integration_test.rs
+---
+# Assets
+
+## main.js
+
+```js
+//#region main.js
+import("./shared.js").then(({ func }) => {
+	func();
+});
+
+//#endregion
+```
+
+## other.js
+
+```js
+
+```
+
+## shared.js
+
+```js
+import { t as func } from "./shared2.js";
+
+export { func };
+```
+
+## shared2.js
+
+```js
+//#region shared.js
+function func() {
+	return "This is a shared function";
+}
+
+//#endregion
+export { func as t };
+```
@@ -0,0 +1,3 @@
+import("./shared.js").then(({ func }) => {
+  func();
+});
@@ -0,0 +1 @@
+import "./shared.js";
@@ -0,0 +1,3 @@
+export function func() {
+  return "This is a shared function";
+}
@@ -12,7 +12,7 @@ console.log("dynamic no-treeshake");
 //#endregion
 //#region dynamic.js
 const lazyLoad = async () => {
-	await import("./main.js");
+	await import("./static2.js");
 	document.body.classList.add("loaded");
 };
 
@@ -23,19 +23,28 @@ export { lazyLoad };
 ## main.js
 
 ```js
-// HIDDEN [rolldown:runtime]
-//#region static.no-treeshake.js
-console.log("static no-treeshake");
+import "./static.js";
 
-//#endregion
-//#region static.js
-var static_exports = /* @__PURE__ */ __exportAll({});
-
-//#endregion
 //#region main.js
 import("./dynamic.js").then(async ({ lazyLoad }) => {
 	await lazyLoad();
 });
 
 //#endregion
 ```
+
+## static.js
+
+```js
+//#region static.no-treeshake.js
+console.log("static no-treeshake");
+
+//#endregion
+```
+
+## static2.js
+
+```js
+import "./static.js";
+
+```
@@ -3908,6 +3908,13 @@ expression: output
 - common-!~{004}~.js => common-CVRK5TUp.js
 - rolldown-runtime-!~{002}~.js => rolldown-runtime-ntFOhXPQ.js
 
+# tests/rolldown/function/advanced_chunks/dynamic_entry_shared_module_not_merged
+
+- main-!~{000}~.js => main-K27wQ6cE.js
+- other-!~{001}~.js => other-B3P9919W.js
+- shared-!~{004}~.js => shared-CclkS2J7.js
+- shared-!~{002}~.js => shared-Cm3wnSX5.js
+
 # tests/rolldown/function/advanced_chunks/include_dependencies_recursively
 
 - main-!~{000}~.js => main-D4MNl3Sj.js
@@ -6361,8 +6368,10 @@ expression: output
 
 # tests/rolldown/tree_shaking/issue_4682
 
-- main-!~{000}~.js => main-CEjIU1Yi.js
-- dynamic-!~{003}~.js => dynamic-YC0iu9Gc.js
+- main-!~{000}~.js => main-B9FlAHGI.js
+- dynamic-!~{005}~.js => dynamic-C1dXXjI-.js
+- static-!~{003}~.js => static-BP37ah8X.js
+- static-!~{001}~.js => static-CE4ZR3EF.js
 
 # tests/rolldown/tree_shaking/json_default_import
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+import("./shared.js").then(({ func }) => {`
	`2`	`+ func();`
	`3`	`+});`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+export function func() {`
	`2`	`+ return "This is a shared function";`
	`3`	`+}`