perf(hmr): consolidate fast incremental updates and lazy-runtime correctness

crates/node_binding/napi-binding.d.ts

@@ -340,7 +340,7 @@ export declare class JsCompiler {
   /** Build with the given option passed to the constructor */
   build(callback: (err: null | Error) => void): void
   /** Rebuild with the given option passed to the constructor */
-  rebuild(changed_files: string[], removed_files: string[], callback: (err: null | Error) => void): void
+  rebuild(changed_files: string[], removed_files: string[], callback: (err: null | Error) => void, is_lazy_watch_rebuild?: boolean): void
   close(): Promise<void>
   getVirtualFileStore(): VirtualFileStore | null
   getCompilerId(): ExternalObject<CompilerId>
@@ -466,20 +466,16 @@ export declare class NativeWatcher {
   constructor(options: NativeWatcherOptions)
   watch(files: [Array<string>, Array<string>], directories: [Array<string>, Array<string>], missing: [Array<string>, Array<string>], startTime: bigint, callback: (err: Error | null, result: NativeWatchResult) => void, callbackUndelayed: (event: NativeWatchUndelayedEvent) => void): void
   triggerEvent(kind: 'change' | 'remove' | 'create', path: string): void
-  /**
-   * # Safety
-   *
-   * This function is unsafe because it uses `&mut self` to call the watcher asynchronously.
-   * It's important to ensure that the watcher is not used in any other places before this function is finished.
-   * You must ensure that the watcher not call watch, close or pause in the same time, otherwise it may lead to undefined behavior.
-   */
+  takePendingEvents(): NativeWatchResult
+  acknowledgePendingEvents(generation: number): void
   close(): Promise<void>
   pause(): void
 }
 
 export declare class NativeWatchResult {
   changedFiles: Array<string>
   removedFiles: Array<string>
+  generation: number
 }
 
 

crates/rspack/tests/compilation_dependencies.rs

@@ -0,0 +1,31 @@
+use rspack::builder::Builder as _;
+use rspack_core::Compiler;
+use rspack_paths::ArcPath;
+use rspack_tasks::within_compiler_context_for_testing_sync;
+
+#[test]
+fn compilation_level_dependencies_stay_in_their_own_added_iterators() {
+  within_compiler_context_for_testing_sync(|| {
+    let mut compiler = Compiler::builder().build().expect("compiler should build");
+    let compilation = &mut compiler.compilation;
+    let file = ArcPath::from("/project/file.tsx");
+    let context = ArcPath::from("/project/context");
+    let missing = ArcPath::from("/project/missing.tsx");
+    let build = ArcPath::from("/project/build.config.js");
+
+    compilation.file_dependencies.insert(file.clone());
+    compilation.context_dependencies.insert(context.clone());
+    compilation.missing_dependencies.insert(missing.clone());
+    compilation.build_dependencies.insert(build.clone());
+
+    let (_, file_added, _, _) = compilation.file_dependencies();
+    let (_, context_added, _, _) = compilation.context_dependencies();
+    let (_, missing_added, _, _) = compilation.missing_dependencies();
+    let (_, build_added, _, _) = compilation.build_dependencies();
+
+    assert_eq!(file_added.cloned().collect::<Vec<_>>(), [file]);
+    assert_eq!(context_added.cloned().collect::<Vec<_>>(), [context]);
+    assert_eq!(missing_added.cloned().collect::<Vec<_>>(), [missing]);
+    assert_eq!(build_added.cloned().collect::<Vec<_>>(), [build]);
+  });
+}

crates/rspack_binding_api/Cargo.toml

@@ -117,7 +117,7 @@ serde                                  = { workspace = true }
 serde_json                             = { workspace = true }
 simd-json                              = { workspace = true }
 swc_core                               = { workspace = true, default-features = false, features = ["ecma_transforms_react"] }
-tokio                                  = { workspace = true, features = ["rt", "rt-multi-thread", "macros", "test-util", "tracing", "parking_lot"] }
+tokio                                  = { workspace = true, features = ["rt", "rt-multi-thread", "macros", "sync", "test-util", "tracing", "parking_lot"] }
 ustr                                   = { workspace = true }
 
 [package.metadata.cargo-shear]

crates/rspack_binding_api/src/compilation/mod.rs

@@ -802,20 +802,19 @@ impl JsCompilation {
             Some(js_opts) => js_opts.into(),
             None => EntryOptions::default(),
           };
-          let dependency = if let Some(map) = entry_dependencies_map.get(&js_dependency.request)
-            && let Some(dependency) = map.get(&options)
-          {
+          let cache_key = (
+            js_context.clone(),
+            js_dependency.request.clone(),
+            options.name.clone(),
+            layer.clone(),
+          );
+          let dependency = if let Some(dependency) = entry_dependencies_map.get(&cache_key) {
             js_dependency.dependency_id = Some(*dependency.id());
             dependency.clone()
           } else {
-            let dependency = js_dependency.resolve(js_context.into(), layer)?;
-            if let Some(map) = entry_dependencies_map.get_mut(&js_dependency.request) {
-              map.insert(options.clone(), dependency.clone());
-            } else {
-              let mut map = FxHashMap::default();
-              map.insert(options.clone(), dependency.clone());
-              entry_dependencies_map.insert(js_dependency.request.clone(), map);
-            }
+            let dependency =
+              js_dependency.resolve(js_context.into(), layer, options.name.is_none())?;
+            entry_dependencies_map.insert(cache_key, dependency.clone());
             dependency
           };
           Ok((dependency, options))
@@ -906,20 +905,18 @@ impl JsCompilation {
             Some(js_opts) => js_opts.into(),
             None => EntryOptions::default(),
           };
-          let dependency = if let Some(map) = include_dependencies_map.get(&js_dependency.request)
-            && let Some(dependency) = map.get(&options)
-          {
+          let cache_key = (
+            js_context.clone(),
+            js_dependency.request.clone(),
+            options.name.clone(),
+            layer.clone(),
+          );
+          let dependency = if let Some(dependency) = include_dependencies_map.get(&cache_key) {
             js_dependency.dependency_id = Some(*dependency.id());
             dependency.clone()
           } else {
-            let dependency = js_dependency.resolve(js_context.into(), layer)?;
-            if let Some(map) = include_dependencies_map.get_mut(&js_dependency.request) {
-              map.insert(options.clone(), dependency.clone());
-            } else {
-              let mut map = FxHashMap::default();
-              map.insert(options.clone(), dependency.clone());
-              include_dependencies_map.insert(js_dependency.request.clone(), map);
-            }
+            let dependency = js_dependency.resolve(js_context.into(), layer, true)?;
+            include_dependencies_map.insert(cache_key, dependency.clone());
             dependency
           };
           Ok((dependency, options))

crates/rspack_binding_api/src/dependencies/entry_dependency.rs

@@ -11,6 +11,7 @@ impl EntryDependency {
     &mut self,
     context: rspack_core::Context,
     layer: Option<String>,
+    is_global: bool,
   ) -> napi::Result<Box<dyn rspack_core::Dependency>> {
     match &self.dependency_id {
       Some(dependency_id) => Err(napi::Error::from_reason(format!(
@@ -21,7 +22,7 @@ impl EntryDependency {
           self.request.clone(),
           context,
           layer,
-          false,
+          is_global,
         )) as rspack_core::BoxDependency;
         self.dependency_id = Some(*dependency.id());
         Ok(dependency)

crates/rspack_binding_api/src/lib.rs

@@ -111,8 +111,7 @@ use std::{
 use napi::{CallContext, bindgen_prelude::*};
 pub use raw_options::{CustomPluginBuilder, register_custom_plugin};
 use rspack_core::{
-  BoxDependency, Compilation, CompilerId, CompilerPlatform, EntryOptions, ModuleIdentifier,
-  PluginExt,
+  BoxDependency, Compilation, CompilerId, CompilerPlatform, ModuleIdentifier, PluginExt,
 };
 use rspack_error::Diagnostic;
 use rspack_fs::{IntermediateFileSystem, NativeFileSystem, ReadableFileSystem};
@@ -131,6 +130,7 @@ use crate::{
   error::{ErrorCode, RspackResultToNapiResultExt},
   fs_node::{HybridFileSystem, NodeFileSystem, ThreadsafeNodeFS},
   module::ModuleObject,
+  module_graph_connection::ModuleGraphConnectionWrapper,
   platform::RawCompilerPlatform,
   plugins::{
     JsCleanupPlugin, JsHooksAdapterPlugin, RegisterJsTapKind, RegisterJsTaps, buildtime_plugins,
@@ -154,6 +154,8 @@ thread_local! {
   static COMPILER_REFERENCES: RefCell<FxHashMap<CompilerId, WeakReference<JsCompiler>>> = Default::default();
 }
 
+type EntryDependencyCacheKey = (String, String, Option<String>, Option<String>);
+
 #[js_function(1)]
 fn cleanup_revoked_modules(ctx: CallContext) -> Result<()> {
   let external = ctx.get::<&mut External<(CompilerId, Vec<ModuleIdentifier>)>>(0)?;
@@ -172,8 +174,8 @@ struct JsCompiler {
   // call drop manually to avoid unnecessary drop overhead in cli build
   compiler: ManuallyDrop<Compiler>,
   state: CompilerState,
-  include_dependencies_map: FxHashMap<String, FxHashMap<EntryOptions, BoxDependency>>,
-  entry_dependencies_map: FxHashMap<String, FxHashMap<EntryOptions, BoxDependency>>,
+  include_dependencies_map: FxHashMap<EntryDependencyCacheKey, BoxDependency>,
+  entry_dependencies_map: FxHashMap<EntryDependencyCacheKey, BoxDependency>,
   compiler_context: Arc<CompilerContext>,
   virtual_file_store: Option<Arc<RwLock<dyn VirtualFileStore>>>,
 }
@@ -388,24 +390,26 @@ impl JsCompiler {
 
   /// Rebuild with the given option passed to the constructor
   #[napi(
-    ts_args_type = "changed_files: string[], removed_files: string[], callback: (err: null | Error) => void"
+    ts_args_type = "changed_files: string[], removed_files: string[], callback: (err: null | Error) => void, is_lazy_watch_rebuild?: boolean"
   )]
   pub fn rebuild(
     &mut self,
     reference: Reference<JsCompiler>,
     changed_files: Vec<String>,
     removed_files: Vec<String>,
     f: Function<'static>,
+    is_lazy_watch_rebuild: Option<bool>,
   ) -> Result<(), ErrorCode> {
     unsafe {
       self.run(reference, |compiler, guard| {
         callbackify(
           f,
           async move {
             let result = compiler
-              .rebuild(
+              .rebuild_with_invalidation_provenance(
                 changed_files.into_iter().collect::<FxHashSet<_>>(),
                 removed_files.into_iter().collect::<FxHashSet<_>>(),
+                is_lazy_watch_rebuild.unwrap_or(false),
               )
               .await
               .to_napi_result_with_message(|e| {
@@ -528,6 +532,7 @@ impl JsCompiler {
     ChunkGroupWrapper::cleanup_last_compilation(compilation_id);
     DependencyWrapper::cleanup_last_compilation(compilation_id);
     AsyncDependenciesBlockWrapper::cleanup_last_compilation(compilation_id);
+    ModuleGraphConnectionWrapper::cleanup_last_compilation(compilation_id);
   }
 }