feat: add build unique id for detecting

crates/node_binding/binding.d.ts

@@ -704,6 +704,7 @@ export interface RawBuiltins {
 
 export interface RawBundlerInfoPluginOptions {
   version: string
+  bundler: string
   force: boolean | string[]
 }
 

crates/rspack_binding_options/src/options/raw_builtins/mod.rs

@@ -474,8 +474,9 @@ impl BuiltinPlugin {
         let plugin_options = downcast_into::<RawBundlerInfoPluginOptions>(self.options)?;
         plugins.push(
           BundlerInfoPlugin::new(
-            RawBundlerInfoModeWrapper(plugin_options.force).into(),
             plugin_options.version,
+            plugin_options.bundler,
+            RawBundlerInfoModeWrapper(plugin_options.force).into(),
           )
           .boxed(),
         )

crates/rspack_binding_options/src/options/raw_builtins/raw_bundle_info.rs

@@ -10,6 +10,7 @@ pub struct RawBundlerInfoModeWrapper(pub RawBundlerInfoMode);
 #[napi(object)]
 pub struct RawBundlerInfoPluginOptions {
   pub version: String,
+  pub bundler: String,
   #[napi(ts_type = "boolean | string[]")]
   pub force: RawBundlerInfoMode,
 }

crates/rspack_core/src/compiler/compilation.rs

@@ -1217,13 +1217,18 @@ impl Compilation {
     ) -> Result<()> {
       let mut runtime_requirements_mut = *requirements;
       let mut runtime_requirements;
-      while !runtime_requirements_mut.is_empty() {
-        requirements.insert(runtime_requirements_mut);
+
+      loop {
         runtime_requirements = runtime_requirements_mut;
         runtime_requirements_mut = RuntimeGlobals::default();
         call_hook(&runtime_requirements, &mut runtime_requirements_mut)?;
         runtime_requirements_mut =
           runtime_requirements_mut.difference(requirements.intersection(runtime_requirements_mut));
+        if runtime_requirements_mut.is_empty() {
+          break;
+        } else {
+          requirements.insert(runtime_requirements_mut);
+        }
       }
       Ok(())
     }

crates/rspack_core/src/runtime_globals.rs

@@ -5,7 +5,7 @@ use swc_core::ecma::atoms::Atom;
 
 bitflags! {
   #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-  pub struct RuntimeGlobals: u64 {
+  pub struct RuntimeGlobals: u128 {
     const REQUIRE_SCOPE = 1 << 0;
 
     /**
@@ -243,6 +243,8 @@ bitflags! {
     const RSPACK_VERSION = 1 << 62;
 
     const HAS_CSS_MODULES = 1 << 63;
+
+    const RSPACK_UNIQUE_ID = 1 << 64;
   }
 }
 
@@ -325,6 +327,7 @@ impl RuntimeGlobals {
       R::PRELOAD_CHUNK_HANDLERS => "__webpack_require__.H",
       // rspack only
       R::RSPACK_VERSION => "__webpack_require__.rv",
+      R::RSPACK_UNIQUE_ID => "__webpack_require__.ruid",
       R::HAS_CSS_MODULES => "has css modules",
       _ => unreachable!(),
     }

crates/rspack_plugin_javascript/src/parser_plugin/api_plugin.rs

@@ -23,6 +23,7 @@ const WEBPACK_CHUNK_NAME: &str = "__webpack_chunkname__";
 const WEBPACK_RUNTIME_ID: &str = "__webpack_runtime_id__";
 const WEBPACK_REQUIRE: &str = RuntimeGlobals::REQUIRE.name();
 const RSPACK_VERSION: &str = "__rspack_version__";
+const RSPACK_UNIQUE_ID: &str = "__rspack_unique_id__";
 
 pub struct APIPluginOptions {
   module: bool,
@@ -226,6 +227,18 @@ impl JavascriptParserPlugin for APIPlugin {
           )));
         Some(true)
       }
+      WEBPACK_RUNTIME_ID => {
+        parser
+          .presentational_dependencies
+          .push(Box::new(ConstDependency::new(
+            ident.span.real_lo(),
+            ident.span.real_hi(),
+            RuntimeGlobals::RUNTIME_ID.name().into(),
+            Some(RuntimeGlobals::RUNTIME_ID),
+          )));
+        Some(true)
+      }
+      // rspack specific
       RSPACK_VERSION => {
         parser
           .presentational_dependencies
@@ -237,14 +250,14 @@ impl JavascriptParserPlugin for APIPlugin {
           )));
         Some(true)
       }
-      WEBPACK_RUNTIME_ID => {
+      RSPACK_UNIQUE_ID => {
         parser
           .presentational_dependencies
           .push(Box::new(ConstDependency::new(
             ident.span.real_lo(),
             ident.span.real_hi(),
-            RuntimeGlobals::RUNTIME_ID.name().into(),
-            Some(RuntimeGlobals::RUNTIME_ID),
+            format!("{}", RuntimeGlobals::RSPACK_UNIQUE_ID).into(),
+            Some(RuntimeGlobals::RSPACK_UNIQUE_ID),
           )));
         Some(true)
       }

crates/rspack_plugin_runtime/src/bundler_info.rs

@@ -1,12 +1,12 @@
 use rspack_core::{
-  ChunkUkey, Compilation, CompilationRuntimeRequirementInTree, Plugin, PluginContext,
-  RuntimeGlobals,
+  ChunkUkey, Compilation, CompilationAdditionalTreeRuntimeRequirements,
+  CompilationRuntimeRequirementInTree, Plugin, PluginContext, RuntimeGlobals,
 };
 use rspack_error::Result;
 use rspack_hook::{plugin, plugin_hook};
 use rustc_hash::FxHashSet;
 
-use crate::runtime_module::RspackVersionRuntimeModule;
+use crate::runtime_module::{RspackUniqueIdRuntimeModule, RspackVersionRuntimeModule};
 
 #[derive(Debug)]
 pub enum BundlerInfoForceMode {
@@ -19,15 +19,43 @@ pub enum BundlerInfoForceMode {
 #[derive(Debug)]
 pub struct BundlerInfoPlugin {
   version: String,
+  bundler_name: String,
   force: BundlerInfoForceMode,
 }
 
 impl BundlerInfoPlugin {
-  pub fn new(force: BundlerInfoForceMode, version: String) -> Self {
-    Self::new_inner(version, force)
+  pub fn new(version: String, bundler_name: String, force: BundlerInfoForceMode) -> Self {
+    Self::new_inner(version, bundler_name, force)
   }
 }
 
+#[plugin_hook(CompilationAdditionalTreeRuntimeRequirements for BundlerInfoPlugin)]
+async fn additional_tree_runtime_requirements(
+  &self,
+  _compilation: &mut Compilation,
+  _chunk_ukey: &ChunkUkey,
+  runtime_requirements: &mut RuntimeGlobals,
+) -> Result<()> {
+  if match &self.force {
+    BundlerInfoForceMode::All => true,
+    BundlerInfoForceMode::Partial(s) => s.get("version").is_some(),
+    BundlerInfoForceMode::Auto => runtime_requirements.contains(RuntimeGlobals::RSPACK_VERSION),
+  } {
+    runtime_requirements.insert(RuntimeGlobals::REQUIRE);
+    runtime_requirements.insert(RuntimeGlobals::RSPACK_VERSION);
+  }
+
+  if match &self.force {
+    BundlerInfoForceMode::All => true,
+    BundlerInfoForceMode::Partial(s) => s.get("uniqueId").is_some(),
+    BundlerInfoForceMode::Auto => runtime_requirements.contains(RuntimeGlobals::RSPACK_UNIQUE_ID),
+  } {
+    runtime_requirements.insert(RuntimeGlobals::REQUIRE);
+    runtime_requirements.insert(RuntimeGlobals::RSPACK_UNIQUE_ID);
+  }
+  Ok(())
+}
+
 #[plugin_hook(CompilationRuntimeRequirementInTree for BundlerInfoPlugin)]
 fn runtime_requirements_in_tree(
   &self,
@@ -36,16 +64,22 @@ fn runtime_requirements_in_tree(
   runtime_requirements: &RuntimeGlobals,
   _runtime_requirements_mut: &mut RuntimeGlobals,
 ) -> Result<Option<()>> {
-  if match &self.force {
-    BundlerInfoForceMode::All => true,
-    BundlerInfoForceMode::Partial(s) => s.get("version").is_some(),
-    BundlerInfoForceMode::Auto => runtime_requirements.contains(RuntimeGlobals::RSPACK_VERSION),
-  } {
+  if runtime_requirements.contains(RuntimeGlobals::RSPACK_VERSION) {
     compilation.add_runtime_module(
       chunk_ukey,
       Box::new(RspackVersionRuntimeModule::new(self.version.clone())),
     )?;
   }
+
+  if runtime_requirements.contains(RuntimeGlobals::RSPACK_UNIQUE_ID) {
+    compilation.add_runtime_module(
+      chunk_ukey,
+      Box::new(RspackUniqueIdRuntimeModule::new(
+        self.bundler_name.clone(),
+        self.version.clone(),
+      )),
+    )?;
+  }
   Ok(None)
 }
 
@@ -59,6 +93,11 @@ impl Plugin for BundlerInfoPlugin {
     ctx: PluginContext<&mut rspack_core::ApplyContext>,
     _options: &mut rspack_core::CompilerOptions,
   ) -> Result<()> {
+    ctx
+      .context
+      .compilation_hooks
+      .additional_tree_runtime_requirements
+      .tap(additional_tree_runtime_requirements::new(self));
     ctx
       .context
       .compilation_hooks

crates/rspack_plugin_runtime/src/runtime_module/mod.rs

@@ -32,6 +32,7 @@ mod public_path;
 mod readfile_chunk_loading;
 mod relative_url;
 mod require_js_chunk_loading;
+mod rspack_unique_id;
 mod rspack_version;
 mod runtime_id;
 mod startup_chunk_dependencies;
@@ -72,6 +73,7 @@ pub use public_path::PublicPathRuntimeModule;
 pub use readfile_chunk_loading::ReadFileChunkLoadingRuntimeModule;
 pub use relative_url::RelativeUrlRuntimeModule;
 pub use require_js_chunk_loading::RequireChunkLoadingRuntimeModule;
+pub use rspack_unique_id::RspackUniqueIdRuntimeModule;
 pub use rspack_version::RspackVersionRuntimeModule;
 pub use runtime_id::RuntimeIdRuntimeModule;
 pub use startup_chunk_dependencies::StartupChunkDependenciesRuntimeModule;

crates/rspack_plugin_runtime/src/runtime_module/rspack_unique_id.rs

@@ -0,0 +1,44 @@
+use rspack_core::{
+  impl_runtime_module,
+  rspack_sources::{BoxSource, RawSource, SourceExt},
+  Compilation, RuntimeModule, RuntimeModuleStage,
+};
+use rspack_identifier::Identifier;
+
+#[impl_runtime_module]
+#[derive(Debug)]
+pub struct RspackUniqueIdRuntimeModule {
+  id: Identifier,
+  bundler_name: String,
+  bundler_version: String,
+}
+
+impl RspackUniqueIdRuntimeModule {
+  pub fn new(bundler_name: String, bundler_version: String) -> Self {
+    Self::with_default(
+      Identifier::from("webpack/runtime/rspack_unique_id"),
+      bundler_name,
+      bundler_version,
+    )
+  }
+}
+
+impl RuntimeModule for RspackUniqueIdRuntimeModule {
+  fn stage(&self) -> RuntimeModuleStage {
+    RuntimeModuleStage::Attach
+  }
+  fn name(&self) -> Identifier {
+    self.id
+  }
+
+  fn generate(&self, _: &Compilation) -> rspack_error::Result<BoxSource> {
+    Ok(
+      RawSource::from(
+        include_str!("runtime/get_unique_id.js")
+          .replace("$BUNDLER_NAME$", &self.bundler_name)
+          .replace("$BUNDLER_VERSION$", &self.bundler_version),
+      )
+      .boxed(),
+    )
+  }
+}

crates/rspack_plugin_runtime/src/runtime_module/runtime/get_unique_id.js

@@ -0,0 +1 @@
+__webpack_require__.ruid = "bundler=$BUNDLER_NAME$@$BUNDLER_VERSION$";

packages/rspack-test-tools/src/processor/builtin.ts

@@ -119,7 +119,12 @@ export class BuiltinProcessor<
 				extensions: [".js"]
 			},
 			experiments: {
-				futureDefaults: true
+				futureDefaults: true,
+				rspackFuture: {
+					bundlerInfo: {
+						force: false
+					}
+				}
 			},
 			devtool: false,
 			context: context.getSource(),

packages/rspack-test-tools/src/processor/config.ts

@@ -55,6 +55,13 @@ export class ConfigProcessor<
 			},
 			optimization: {
 				minimize: false
+			},
+			experiments: {
+				rspackFuture: {
+					bundlerInfo: {
+						force: false
+					}
+				}
 			}
 		} as TCompilerOptions<T>;
 	}

packages/rspack-test-tools/src/processor/diagnostic.ts

@@ -70,7 +70,14 @@ export class DiagnosticProcessor<
 			},
 			output: {
 				path: context.getDist()
+			},
+			experiments: {
+				rspackFuture: {
+					bundlerInfo: {
+						force: false
+					}
+				}
 			}
-		};
+		} as TCompilerOptions<T>;
 	}
 }

packages/rspack-test-tools/src/processor/diff.ts

@@ -147,7 +147,17 @@ export class DiffProcessor implements ITestProcessor {
 			plugins: [
 				type === ECompilerType.Webpack && new WebpackDiffConfigPlugin(),
 				type === ECompilerType.Rspack && new RspackDiffConfigPlugin()
-			].filter(Boolean)
+			].filter(Boolean),
+			experiments:
+				type === ECompilerType.Rspack
+					? {
+							rspackFuture: {
+								bundlerInfo: {
+									force: false
+								}
+							}
+						}
+					: {}
 		} as TCompilerOptions<T>;
 	}
 

packages/rspack-test-tools/src/processor/error.ts

@@ -88,6 +88,13 @@ export class ErrorProcessor<
 					devtool: false,
 					optimization: {
 						minimize: false
+					},
+					experiments: {
+						rspackFuture: {
+							bundlerInfo: {
+								force: false
+							}
+						}
 					}
 				} as TCompilerOptions<T>;
 				if (typeof _errorOptions.options === "function") {

packages/rspack-test-tools/src/processor/hash.ts

@@ -55,8 +55,15 @@ export class HashProcessor<
 			context: context.getSource(),
 			output: {
 				path: context.getDist()
+			},
+			experiments: {
+				rspackFuture: {
+					bundlerInfo: {
+						force: false
+					}
+				}
 			}
-		};
+		} as TCompilerOptions<T>;
 	}
 	static overrideOptions<T extends ECompilerType>(
 		index: number,

packages/rspack-test-tools/src/processor/hook.ts

@@ -230,6 +230,13 @@ export class HookTaskProcessor<
 			},
 			optimization: {
 				minimize: false
+			},
+			experiments: {
+				rspackFuture: {
+					bundlerInfo: {
+						force: false
+					}
+				}
 			}
 		} as TCompilerOptions<T>;
 	}