diff --git a/crates/next-core/src/next_config.rs b/crates/next-core/src/next_config.rs
index dba9ce2f5558..c409d0331a6a 100644
--- a/crates/next-core/src/next_config.rs
+++ b/crates/next-core/src/next_config.rs
@@ -96,6 +96,7 @@ pub struct NextConfig {
     experimental: ExperimentalConfig,
     images: ImageConfig,
     page_extensions: Vec<RcStr>,
+    instrumentation_client_inject: Option<Vec<RcStr>>,
     react_compiler: Option<ReactCompilerOptionsOrBoolean>,
     react_production_profiling: Option<bool>,
     react_strict_mode: Option<bool>,
@@ -1219,7 +1220,6 @@ pub struct ExperimentalConfig {
     /// This field is kept for backwards compatibility during migration.
     cache_components: Option<bool>,
     use_cache: Option<bool>,
-    root_params: Option<bool>,
     runtime_server_deployment_id: Option<bool>,
     supports_immutable_assets: Option<bool>,
 
@@ -1796,6 +1796,15 @@ impl NextConfig {
         Vc::cell(extensions)
     }
 
+    #[turbo_tasks::function]
+    pub fn instrumentation_client_inject(&self) -> Vc<Vec<RcStr>> {
+        Vc::cell(
+            self.instrumentation_client_inject
+                .clone()
+                .unwrap_or_default(),
+        )
+    }
+
     #[turbo_tasks::function]
     pub fn is_global_not_found_enabled(&self) -> Vc<bool> {
         Vc::cell(self.experimental.global_not_found.unwrap_or_default())
@@ -2169,16 +2178,6 @@ impl NextConfig {
         )
     }
 
-    #[turbo_tasks::function]
-    pub fn enable_root_params(&self) -> Vc<bool> {
-        Vc::cell(
-            self.experimental
-                .root_params
-                // rootParams should be enabled implicitly in cacheComponents.
-                .unwrap_or(self.cache_components.unwrap_or(false)),
-        )
-    }
-
     #[turbo_tasks::function]
     pub fn is_using_adapter(&self) -> Vc<bool> {
         Vc::cell(self.adapter_path.is_some())
diff --git a/crates/next-core/src/next_import_map.rs b/crates/next-core/src/next_import_map.rs
index 0579532e00e7..31da89706419 100644
--- a/crates/next-core/src/next_import_map.rs
+++ b/crates/next-core/src/next_import_map.rs
@@ -7,12 +7,13 @@ use next_taskless::{EDGE_NODE_EXTERNALS, NODE_EXTERNALS};
 use rustc_hash::FxHashMap;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{FxIndexMap, ResolvedVc, Vc, fxindexmap};
-use turbo_tasks_fs::{FileSystem, FileSystemPath, to_sys_path};
+use turbo_tasks_fs::{FileContent, FileSystem, FileSystemPath, to_sys_path};
 use turbopack_core::{
+    asset::AssetContent,
     issue::{Issue, IssueExt, IssueSeverity, IssueStage, StyledString},
     reference_type::{CommonJsReferenceSubType, ReferenceType},
     resolve::{
-        AliasPattern, ExternalTraced, ExternalType, ResolveAliasMap, SubpathValue,
+        AliasPattern, ExternalTraced, ExternalType, ResolveAliasMap, ResolveResult, SubpathValue,
         node::node_cjs_resolve_options,
         options::{ConditionValue, ImportMap, ImportMapping, ResolvedMap},
         parse::Request,
@@ -20,6 +21,7 @@ use turbopack_core::{
         resolve,
     },
     source::Source,
+    virtual_source::VirtualSource,
 };
 use turbopack_node::execution_context::ExecutionContext;
 
@@ -209,13 +211,7 @@ pub async fn get_next_client_import_map(
         rcstr!("next/dist/compiled/server-only") => rcstr!("next/dist/compiled/server-only/index"),
         rcstr!("next/dist/compiled/client-only") => rcstr!("next/dist/compiled/client-only/index"),},
     );
-    insert_next_root_params_mapping(
-        &mut import_map,
-        next_config.enable_root_params(),
-        Either::Right(ty.clone()),
-        None,
-    )
-    .await?;
+    insert_next_root_params_mapping(&mut import_map, Either::Right(ty.clone()), None).await?;
 
     match ty {
         ClientContextType::Pages { .. }
@@ -231,7 +227,7 @@ pub async fn get_next_client_import_map(
         ClientContextType::Other => {}
     }
 
-    insert_instrumentation_client_alias(&mut import_map, project_path).await?;
+    insert_instrumentation_client_alias(&mut import_map, project_path, next_config).await?;
 
     insert_server_only_error_alias(&mut import_map);
 
@@ -745,13 +741,7 @@ async fn insert_next_server_special_aliases(
         }
     }
 
-    insert_next_root_params_mapping(
-        import_map,
-        next_config.enable_root_params(),
-        Either::Left(ty),
-        collected_root_params,
-    )
-    .await?;
+    insert_next_root_params_mapping(import_map, Either::Left(ty), collected_root_params).await?;
 
     import_map.insert_exact_alias(
         rcstr!("@vercel/og"),
@@ -1376,24 +1366,81 @@ fn insert_package_alias(import_map: &mut ImportMap, prefix: &str, package_root:
     );
 }
 
-/// Handles instrumentation-client.ts bundling logic
+/// Handles instrumentation-client.ts bundling logic.
+///
+/// Resolves the `private-next-instrumentation-client` alias to a virtual module
+/// that first requires each entry of `instrumentationClientInject` for side
+/// effects (in array order) and then re-exports the user's
+/// `instrumentation-client.{pageExt}` file via the
+/// `private-next-instrumentation-client-user` alias.
 async fn insert_instrumentation_client_alias(
     import_map: &mut ImportMap,
     project_path: FileSystemPath,
+    next_config: Vc<NextConfig>,
 ) -> Result<()> {
+    let user_file_alternatives = vec![
+        request_to_import_mapping(project_path.clone(), rcstr!("./src/instrumentation-client")),
+        request_to_import_mapping(
+            project_path.clone(),
+            rcstr!("./src/instrumentation-client.ts"),
+        ),
+        request_to_import_mapping(project_path.clone(), rcstr!("./instrumentation-client")),
+        request_to_import_mapping(project_path.clone(), rcstr!("./instrumentation-client.ts")),
+        ImportMapping::Ignore.resolved_cell(),
+    ];
+
+    let injects = next_config.instrumentation_client_inject().await?;
+
+    if injects.is_empty() {
+        insert_alias_to_alternatives(
+            import_map,
+            rcstr!("private-next-instrumentation-client"),
+            user_file_alternatives,
+        );
+        return Ok(());
+    }
+
+    // The user file is reached through a separate alias so the existing
+    // alternative resolution stays unchanged.
     insert_alias_to_alternatives(
         import_map,
+        rcstr!("private-next-instrumentation-client-user"),
+        user_file_alternatives,
+    );
+
+    let injects = injects
+        .iter()
+        .map(|s| s.as_str())
+        .chain(std::iter::once("private-next-instrumentation-client-user"));
+
+    let mut body = String::new();
+    for (i, spec) in injects.clone().enumerate() {
+        body.push_str(&format!(
+            "var mod_{i} = require({});\n",
+            serde_json::to_string(spec)?
+        ));
+    }
+    body.push_str("module.exports = { onRouterTransitionStart(url, type) {\n");
+    for (i, _) in injects.enumerate() {
+        body.push_str(&format!(
+            "    mod_{i}?.onRouterTransitionStart?.(url, type);\n"
+        ));
+    }
+    body.push_str("}};\n");
+
+    let virtual_source = VirtualSource::new(
+        project_path.join("__next_instrumentation_client.js")?,
+        AssetContent::file(FileContent::Content(body.into()).cell()),
+    )
+    .to_resolved()
+    .await?;
+
+    import_map.insert_exact_alias(
         rcstr!("private-next-instrumentation-client"),
-        vec![
-            request_to_import_mapping(project_path.clone(), rcstr!("./src/instrumentation-client")),
-            request_to_import_mapping(
-                project_path.clone(),
-                rcstr!("./src/instrumentation-client.ts"),
-            ),
-            request_to_import_mapping(project_path.clone(), rcstr!("./instrumentation-client")),
-            request_to_import_mapping(project_path.clone(), rcstr!("./instrumentation-client.ts")),
-            ImportMapping::Ignore.resolved_cell(),
-        ],
+        ImportMapping::Direct(
+            ResolveResult::source(ResolvedVc::upcast(virtual_source)).resolved_cell(),
+        )
+        .resolved_cell(),
     );
 
     Ok(())
diff --git a/crates/next-core/src/next_root_params/mod.rs b/crates/next-core/src/next_root_params/mod.rs
index c9a3acdb6818..0e291da2deda 100644
--- a/crates/next-core/src/next_root_params/mod.rs
+++ b/crates/next-core/src/next_root_params/mod.rs
@@ -30,26 +30,20 @@ use crate::{
 
 pub async fn insert_next_root_params_mapping(
     import_map: &mut ImportMap,
-    is_root_params_enabled: Vc<bool>,
     ty: Either<ServerContextType, ClientContextType>,
     collected_root_params: Option<Vc<CollectedRootParams>>,
 ) -> Result<()> {
     import_map.insert_exact_alias(
         "next/root-params",
-        get_next_root_params_mapping(
-            is_root_params_enabled,
-            EitherTaskInput(ty),
-            collected_root_params,
-        )
-        .to_resolved()
-        .await?,
+        get_next_root_params_mapping(EitherTaskInput(ty), collected_root_params)
+            .to_resolved()
+            .await?,
     );
     Ok(())
 }
 
 #[turbo_tasks::function]
 async fn get_next_root_params_mapping(
-    is_root_params_enabled: Vc<bool>,
     ty: EitherTaskInput<ServerContextType, ClientContextType>,
     collected_root_params: Option<Vc<CollectedRootParams>>,
 ) -> Result<Vc<ImportMapping>> {
@@ -61,7 +55,7 @@ async fn get_next_root_params_mapping(
     // `collected_root_params` changes, the resolve options will remain the same, and
     // only the mapping result will be invalidated.
     let mapping = ImportMapping::Dynamic(ResolvedVc::upcast(
-        NextRootParamsMapper::new(is_root_params_enabled, ty, collected_root_params)
+        NextRootParamsMapper::new(ty, collected_root_params)
             .to_resolved()
             .await?,
     ));
@@ -70,7 +64,6 @@ async fn get_next_root_params_mapping(
 
 #[turbo_tasks::value]
 struct NextRootParamsMapper {
-    is_root_params_enabled: ResolvedVc<bool>,
     #[bincode(with = "turbo_bincode::either")]
     context_type: Either<ServerContextType, ClientContextType>,
     collected_root_params: Option<ResolvedVc<CollectedRootParams>>,
@@ -80,12 +73,10 @@ struct NextRootParamsMapper {
 impl NextRootParamsMapper {
     #[turbo_tasks::function]
     pub fn new(
-        is_root_params_enabled: ResolvedVc<bool>,
         context_type: EitherTaskInput<ServerContextType, ClientContextType>,
         collected_root_params: Option<ResolvedVc<CollectedRootParams>>,
     ) -> Vc<Self> {
         NextRootParamsMapper {
-            is_root_params_enabled,
             context_type: context_type.0,
             collected_root_params,
         }
@@ -95,61 +86,47 @@ impl NextRootParamsMapper {
     #[turbo_tasks::function]
     async fn import_map_result(self: Vc<Self>) -> Result<Vc<ImportMapResult>> {
         let this = self.await?;
-        Ok({
-            if !(*this.is_root_params_enabled.await?) {
+        Ok(match &this.context_type {
+            Either::Left(server_ty) => match &server_ty {
+                ServerContextType::AppRSC { .. } | ServerContextType::AppRoute { .. } => {
+                    let collected_root_params = *this.collected_root_params.ok_or_else(|| {
+                        anyhow!(
+                            "Invariant: Root params should have been collected for context {:?}. \
+                             This is a bug in Next.js.",
+                            server_ty.clone()
+                        )
+                    })?;
+                    Self::valid_import_map_result(collected_root_params)
+                }
+                ServerContextType::PagesApi { .. }
+                | ServerContextType::Instrumentation { .. }
+                | ServerContextType::Middleware { .. } => {
+                    // There's no sensible way to use root params outside of the app
+                    // directory. TODO: make sure this error is consistent with webpack
+                    Self::invalid_import_map_result(
+                        "'next/root-params' can only be used inside the App Directory.".into(),
+                    )
+                }
+                _ => {
+                    // In general, the compiler should prevent importing 'next/root-params'
+                    // from client modules, but it doesn't catch everything. If an import
+                    // slips through our validation, make it error.
+                    Self::invalid_import_map_result(
+                        "'next/root-params' cannot be imported from a Client Component module. It \
+                         should only be used from a Server Component."
+                            .into(),
+                    )
+                }
+            },
+            Either::Right(_) => {
+                // In general, the compiler should prevent importing 'next/root-params' from
+                // client modules, but it doesn't catch everything. If an import slips
+                // through our validation, make it error.
                 Self::invalid_import_map_result(
-                    "'next/root-params' can only be imported when `experimental.rootParams` is \
-                     enabled."
+                    "'next/root-params' cannot be imported from a Client Component module. It \
+                     should only be used from a Server Component."
                         .into(),
                 )
-            } else {
-                match &this.context_type {
-                    Either::Left(server_ty) => match &server_ty {
-                        ServerContextType::AppRSC { .. } | ServerContextType::AppRoute { .. } => {
-                            let collected_root_params =
-                                *this.collected_root_params.ok_or_else(|| {
-                                    anyhow!(
-                                        "Invariant: Root params should have been collected for \
-                                         context {:?}. This is a bug in Next.js.",
-                                        server_ty.clone()
-                                    )
-                                })?;
-                            Self::valid_import_map_result(collected_root_params)
-                        }
-                        ServerContextType::PagesApi { .. }
-                        | ServerContextType::Instrumentation { .. }
-                        | ServerContextType::Middleware { .. } => {
-                            // There's no sensible way to use root params outside of the app
-                            // directory. TODO: make sure this error is
-                            // consistent with webpack
-                            Self::invalid_import_map_result(
-                                "'next/root-params' can only be used inside the App Directory."
-                                    .into(),
-                            )
-                        }
-                        _ => {
-                            // In general, the compiler should prevent importing 'next/root-params'
-                            // from client modules, but it doesn't catch
-                            // everything. If an import slips through
-                            // our validation, make it error.
-                            Self::invalid_import_map_result(
-                                "'next/root-params' cannot be imported from a Client Component \
-                                 module. It should only be used from a Server Component."
-                                    .into(),
-                            )
-                        }
-                    },
-                    Either::Right(_) => {
-                        // In general, the compiler should prevent importing 'next/root-params' from
-                        // client modules, but it doesn't catch everything. If an
-                        // import slips through our validation, make it error.
-                        Self::invalid_import_map_result(
-                            "'next/root-params' cannot be imported from a Client Component \
-                             module. It should only be used from a Server Component."
-                                .into(),
-                        )
-                    }
-                }
             }
         })
     }
diff --git a/packages/next/src/build/create-compiler-aliases.ts b/packages/next/src/build/create-compiler-aliases.ts
index a258469fc5f7..c9ef02997af2 100644
--- a/packages/next/src/build/create-compiler-aliases.ts
+++ b/packages/next/src/build/create-compiler-aliases.ts
@@ -25,6 +25,17 @@ interface CompilerAliases {
 
 const isReact19 = typeof React.use === 'function'
 
+/**
+ * Absolute path to the placeholder file that `private-next-instrumentation-client`
+ * resolves to. Its contents are replaced at build time by
+ * `next-instrumentation-client-loader` via a `module.rules` entry in
+ * `webpack-config.ts`.
+ */
+const INSTRUMENTATION_CLIENT_STUB_PATH = path.join(
+  NEXT_PROJECT_ROOT,
+  'dist/build/webpack/loaders/instrumentation-client-stub.js'
+)
+
 export function createWebpackAliases({
   distDir,
   isClient,
@@ -138,7 +149,17 @@ export function createWebpackAliases({
     [ROOT_DIR_ALIAS]: dir,
     ...(isClient
       ? {
-          'private-next-instrumentation-client': [
+          // `private-next-instrumentation-client` resolves to a placeholder
+          // file whose contents are replaced at build time by
+          // `next-instrumentation-client-loader` (registered via a
+          // `module.rules` entry in webpack-config.ts). The emitted module
+          // requires each `instrumentationClientInject` entry for side effects,
+          // then re-exports the user's `instrumentation-client.{pageExt}` file
+          // (resolved through the `private-next-instrumentation-client-user`
+          // alias below).
+          'private-next-instrumentation-client':
+            INSTRUMENTATION_CLIENT_STUB_PATH,
+          'private-next-instrumentation-client-user': [
             path.join(dir, 'src', 'instrumentation-client'),
             path.join(dir, 'instrumentation-client'),
             'private-next-empty-module',
diff --git a/packages/next/src/build/index.ts b/packages/next/src/build/index.ts
index bba1cd4a6529..ed0149b61654 100644
--- a/packages/next/src/build/index.ts
+++ b/packages/next/src/build/index.ts
@@ -1430,8 +1430,7 @@ export default async function build(
 
           await writeRootParamsTypes(
             routeTypesManifest,
-            path.join(distDir, 'types', 'root-params.d.ts'),
-            config
+            path.join(distDir, 'types', 'root-params.d.ts')
           )
         })
 
diff --git a/packages/next/src/build/type-check.ts b/packages/next/src/build/type-check.ts
index 3b2fe44a8722..861f31d3b36e 100644
--- a/packages/next/src/build/type-check.ts
+++ b/packages/next/src/build/type-check.ts
@@ -31,8 +31,7 @@ function verifyAndRunTypeScript(
   hasPagesDir: boolean,
   appDir: string | undefined,
   pagesDir: string | undefined,
-  debugBuildPaths: { app: string[]; pages: string[] } | undefined,
-  rootParams: boolean
+  debugBuildPaths: { app: string[]; pages: string[] } | undefined
 ) {
   let impl: typeof import('../lib/verify-typescript-setup').verifyAndRunTypeScript
   let typeCheckWorker:
@@ -75,7 +74,6 @@ function verifyAndRunTypeScript(
     appDir,
     pagesDir,
     debugBuildPaths,
-    rootParams,
   })
     .then((result) => {
       typeCheckWorker?.end()
@@ -144,8 +142,7 @@ export async function startTypeChecking({
           !!pagesDir,
           appDir,
           pagesDir,
-          debugBuildPaths,
-          !!config.experimental.rootParams || !!config.cacheComponents
+          debugBuildPaths
         ).then((resolved) => {
           const checkEnd = process.hrtime(typeCheckAndLintStart)
           return [resolved, checkEnd] as const
diff --git a/packages/next/src/build/webpack-config.ts b/packages/next/src/build/webpack-config.ts
index 87ca8879d491..59be2705f54e 100644
--- a/packages/next/src/build/webpack-config.ts
+++ b/packages/next/src/build/webpack-config.ts
@@ -1360,6 +1360,7 @@ export default async function getBaseWebpackConfig(
         'error-loader',
         'next-swc-loader',
         'next-client-pages-loader',
+        'next-instrumentation-client-loader',
         'next-image-loader',
         'next-metadata-image-loader',
         'next-style-loader',
@@ -1576,11 +1577,6 @@ export default async function getBaseWebpackConfig(
           : []),
 
         ...getNextRootParamsRules({
-          isRootParamsEnabled:
-            config.experimental.rootParams ??
-            // `cacheComponents` implies `experimental.rootParams`.
-            config.cacheComponents ??
-            false,
           isClient,
           appDir,
           pageExtensions,
@@ -1933,6 +1929,20 @@ export default async function getBaseWebpackConfig(
           test: /[\\/]next[\\/]dist[\\/](esm[\\/])?build[\\/]webpack[\\/]loaders[\\/]next-flight-loader[\\/]action-client-wrapper\.js/,
           sideEffects: false,
         },
+        // The placeholder file aliased from `private-next-instrumentation-client`.
+        // The loader replaces its contents with a synthetic module that
+        // requires each `instrumentationClientInject` entry, then re-exports
+        // the user's `instrumentation-client.{pageExt}` (composing
+        // `onRouterTransitionStart` hooks across all of them).
+        {
+          test: /[\\/]next[\\/]dist[\\/](esm[\\/])?build[\\/]webpack[\\/]loaders[\\/]instrumentation-client-stub\.js$/,
+          use: {
+            loader: 'next-instrumentation-client-loader',
+            options: {
+              injects: JSON.stringify(config.instrumentationClientInject),
+            },
+          },
+        },
         {
           // This loader rule should be before other rules, as it can output code
           // that still contains `"use client"` or `"use server"` statements that
@@ -2866,12 +2876,10 @@ export default async function getBaseWebpackConfig(
 }
 
 function getNextRootParamsRules({
-  isRootParamsEnabled,
   isClient,
   appDir,
   pageExtensions,
 }: {
-  isRootParamsEnabled: boolean
   isClient: boolean
   appDir: string | undefined
   pageExtensions: string[]
@@ -2889,15 +2897,6 @@ function getNextRootParamsRules({
     } satisfies webpack.RuleSetRule
   }
 
-  // Hard-error if the flag is not enabled, regardless of if we're on the server or on the client.
-  if (!isRootParamsEnabled) {
-    return [
-      createInvalidImportRule(
-        "'next/root-params' can only be imported when `experimental.rootParams` is enabled."
-      ),
-    ]
-  }
-
   // If there's no app-dir (and thus no layouts), there's no sensible way to use 'next/root-params',
   // because we wouldn't generate any getters.
   if (!appDir) {
diff --git a/packages/next/src/build/webpack/loaders/instrumentation-client-stub.js b/packages/next/src/build/webpack/loaders/instrumentation-client-stub.js
new file mode 100644
index 000000000000..e61ff82110d4
--- /dev/null
+++ b/packages/next/src/build/webpack/loaders/instrumentation-client-stub.js
@@ -0,0 +1,5 @@
+// Placeholder module. The `private-next-instrumentation-client` webpack alias
+// resolves to this file so the resolver has a real path to find; its contents
+// are then replaced by `next-instrumentation-client-loader` via a `module.rules`
+// entry in webpack-config.ts.
+module.exports = {}
diff --git a/packages/next/src/build/webpack/loaders/next-instrumentation-client-loader.ts b/packages/next/src/build/webpack/loaders/next-instrumentation-client-loader.ts
new file mode 100644
index 000000000000..2c9efe1ab16d
--- /dev/null
+++ b/packages/next/src/build/webpack/loaders/next-instrumentation-client-loader.ts
@@ -0,0 +1,73 @@
+import { promisify } from 'util'
+import type { webpack } from 'next/dist/compiled/webpack/webpack'
+
+/**
+ * Loader options for `next-instrumentation-client-loader`. The list of inject
+ * specifiers is JSON-stringified so it can travel through the loader query
+ * string.
+ */
+export type InstrumentationClientLoaderOptions = {
+  /** JSON-stringified `string[]` of module specifiers. */
+  injects: string
+}
+
+const NextInstrumentationClientLoader: webpack.LoaderDefinitionFunction<InstrumentationClientLoaderOptions> =
+  function () {
+    const callback = this.async()
+    const { injects: injectsStringified } = this.getOptions()
+    const injects = JSON.parse(injectsStringified || '[]') as string[]
+
+    // No injects: the alias is a transparent passthrough to the user's
+    // `instrumentation-client.{pageExt}` (or the empty module fallback).
+    if (injects.length === 0) {
+      callback(
+        null,
+        `module.exports = require('private-next-instrumentation-client-user');\n`
+      )
+      return
+    }
+
+    // Resolve each inject specifier against the project root so the emitted
+    // `require()` calls don't get resolved relative to the stub's location
+    // inside `node_modules/next/`. Bare specifiers (npm package names) are
+    // resolved against the project's `node_modules`.
+    const resolve = promisify(this.resolve)
+    const rootContext = this.rootContext
+
+    Promise.all(injects.map((spec) => resolve(rootContext, spec)))
+      .then((resolvedInjects) => {
+        const allModules = [
+          ...resolvedInjects,
+          'private-next-instrumentation-client-user',
+        ]
+
+        const lines: string[] = []
+        allModules.forEach((spec, i) => {
+          lines.push(`var mod_${i} = require(${JSON.stringify(spec)});`)
+        })
+
+        // Compose a single `onRouterTransitionStart` that fans out to every
+        // module's hook (when exported), in array order, with the user file's
+        // hook running last.
+        const hookCalls = allModules
+          .map(
+            // Webpack doesn't transpile this, so use a manual version of optional chaining.
+            (_, i) =>
+              `    mod_${i} && mod_${i}.onRouterTransitionStart && mod_${i}.onRouterTransitionStart(url, type);`
+          )
+          .join('\n')
+
+        lines.push(
+          `module.exports = {`,
+          `  onRouterTransitionStart: function (url, type) {`,
+          hookCalls,
+          `  },`,
+          `};`
+        )
+
+        callback(null, lines.join('\n') + '\n')
+      })
+      .catch((err) => callback(err))
+  }
+
+export default NextInstrumentationClientLoader
diff --git a/packages/next/src/cli/next-test.ts b/packages/next/src/cli/next-test.ts
index 166678d9aa2d..f48d76b88e23 100644
--- a/packages/next/src/cli/next-test.ts
+++ b/packages/next/src/cli/next-test.ts
@@ -149,8 +149,6 @@ async function runPlaywright(
       hasPagesDir: !!pagesDir,
       appDir: appDir || undefined,
       pagesDir: pagesDir || undefined,
-      rootParams:
-        !!nextConfig.experimental.rootParams || !!nextConfig.cacheComponents,
     })
 
     const isUsingTypeScript = !!typeScriptVersion
diff --git a/packages/next/src/cli/next-typegen.ts b/packages/next/src/cli/next-typegen.ts
index 27fbdf8d7c16..976990959a92 100644
--- a/packages/next/src/cli/next-typegen.ts
+++ b/packages/next/src/cli/next-typegen.ts
@@ -55,8 +55,6 @@ const nextTypegen = async (
     hasPagesDir: !!pagesDir,
     appDir: appDir || undefined,
     pagesDir: pagesDir || undefined,
-    rootParams:
-      !!nextConfig.experimental.rootParams || !!nextConfig.cacheComponents,
   })
 
   console.log('Generating route types...')
@@ -117,8 +115,7 @@ const nextTypegen = async (
 
   await writeRootParamsTypes(
     routeTypesManifest,
-    join(distDir, 'types', 'root-params.d.ts'),
-    nextConfig
+    join(distDir, 'types', 'root-params.d.ts')
   )
 
   console.log('✓ Types generated successfully')
diff --git a/packages/next/src/client/.vercel.approvers b/packages/next/src/client/.vercel.approvers
deleted file mode 100644
index 278e04f7809c..000000000000
--- a/packages/next/src/client/.vercel.approvers
+++ /dev/null
@@ -1,3 +0,0 @@
-use-intersection.tsx @timneutkens:notify
-use-intersection.tsx @ijjk:notify
-use-intersection.tsx @shuding:notify
diff --git a/packages/next/src/client/components/segment-cache/cache.ts b/packages/next/src/client/components/segment-cache/cache.ts
index d0ecf46e1cdb..3430c3ac7ffc 100644
--- a/packages/next/src/client/components/segment-cache/cache.ts
+++ b/packages/next/src/client/components/segment-cache/cache.ts
@@ -2594,6 +2594,24 @@ function fulfillEntrySpawnedByRuntimePrefetch(
     PendingSegmentCacheEntry
   > | null
 ) {
+  // Decide whether to re-key the entry under a more generic vary path based on
+  // which params the segment actually depends on.
+  //
+  // Skip re-keying for Full prefetches: as of today, `varyParams` tracking only
+  // works within the static stage portion of a response. A Full prefetch
+  // response covers all stages, and we can't track params during the dynamic
+  // stage without dead-locking the Flight stream, so the server-reported set is
+  // incomplete and can't be trusted for the full response. Re-keying with an
+  // untrustworthy set could replace concrete params with Fallback and let
+  // unrelated URLs read each other's content from the cache.
+  //
+  // When non-null, this is the param set to re-key by; when null, the entry
+  // stays keyed by the request's concrete vary path.
+  const fulfilledVaryParams =
+    process.env.__NEXT_VARY_PARAMS && fetchStrategy !== FetchStrategy.Full
+      ? segmentVaryParams
+      : null
+
   // We should only write into cache entries that are owned by us. Or create
   // a new one and write into that. We must never write over an entry that was
   // created by a different task, because that causes data races.
@@ -2608,11 +2626,10 @@ function fulfillEntrySpawnedByRuntimePrefetch(
       staleAt,
       isPartial
     )
-    // Re-key the entry based on which params the segment actually depends on.
-    if (process.env.__NEXT_VARY_PARAMS && segmentVaryParams !== null) {
+    if (fulfilledVaryParams !== null) {
       const fulfilledVaryPath = getFulfilledSegmentVaryPath(
         tree.varyPath,
-        segmentVaryParams
+        fulfilledVaryParams
       )
       const isRevalidation = false
       setInCacheMap(
@@ -2638,11 +2655,10 @@ function fulfillEntrySpawnedByRuntimePrefetch(
         staleAt,
         isPartial
       )
-      // Re-key the entry based on which params the segment actually depends on.
-      if (process.env.__NEXT_VARY_PARAMS && segmentVaryParams !== null) {
+      if (fulfilledVaryParams !== null) {
         const fulfilledVaryPath = getFulfilledSegmentVaryPath(
           tree.varyPath,
-          segmentVaryParams
+          fulfilledVaryParams
         )
         const isRevalidation = false
         setInCacheMap(
@@ -2664,11 +2680,9 @@ function fulfillEntrySpawnedByRuntimePrefetch(
         staleAt,
         isPartial
       )
-      // Use the fulfilled vary path if available, otherwise fall back to
-      // the request vary path.
       const varyPath =
-        process.env.__NEXT_VARY_PARAMS && segmentVaryParams !== null
-          ? getFulfilledSegmentVaryPath(tree.varyPath, segmentVaryParams)
+        fulfilledVaryParams !== null
+          ? getFulfilledSegmentVaryPath(tree.varyPath, fulfilledVaryParams)
           : getSegmentVaryPathForRequest(fetchStrategy, tree)
       upsertSegmentEntry(now, varyPath, newEntry)
     }
diff --git a/packages/next/src/lib/typescript/writeAppTypeDeclarations.ts b/packages/next/src/lib/typescript/writeAppTypeDeclarations.ts
index 4832a3acefeb..22112f835159 100644
--- a/packages/next/src/lib/typescript/writeAppTypeDeclarations.ts
+++ b/packages/next/src/lib/typescript/writeAppTypeDeclarations.ts
@@ -10,7 +10,6 @@ export async function writeAppTypeDeclarations({
   hasAppDir,
   strictRouteTypes,
   typedRoutes,
-  rootParams,
 }: {
   baseDir: string
   distDir: string
@@ -19,7 +18,6 @@ export async function writeAppTypeDeclarations({
   hasAppDir: boolean
   strictRouteTypes: boolean
   typedRoutes: boolean
-  rootParams: boolean
 }): Promise<void> {
   // Reference `next` types
   const appTypeDeclarations = path.join(baseDir, 'next-env.d.ts')
@@ -71,13 +69,11 @@ export async function writeAppTypeDeclarations({
   // Use ESM import instead of triple-slash reference for better ESLint compatibility
   lines.push(`import "./${routeTypesPath}";`)
 
-  if (rootParams) {
-    const rootParamsTypesPath = path.posix.join(
-      distDir.replaceAll(path.win32.sep, path.posix.sep),
-      'types/root-params.d.ts'
-    )
-    lines.push(`import "./${rootParamsTypesPath}";`)
-  }
+  const rootParamsTypesPath = path.posix.join(
+    distDir.replaceAll(path.win32.sep, path.posix.sep),
+    'types/root-params.d.ts'
+  )
+  lines.push(`import "./${rootParamsTypesPath}";`)
 
   if (strictRouteTypes) {
     const cacheLifePath = path.posix.join(
diff --git a/packages/next/src/lib/verify-typescript-setup.ts b/packages/next/src/lib/verify-typescript-setup.ts
index 3983696d6ba2..52c63d869348 100644
--- a/packages/next/src/lib/verify-typescript-setup.ts
+++ b/packages/next/src/lib/verify-typescript-setup.ts
@@ -67,7 +67,6 @@ export async function verifyAndRunTypeScript({
   appDir,
   pagesDir,
   debugBuildPaths,
-  rootParams,
 }: {
   dir: string
   distDir: string
@@ -82,7 +81,6 @@ export async function verifyAndRunTypeScript({
   appDir?: string
   pagesDir?: string
   debugBuildPaths?: { app?: string[]; pages?: string[] }
-  rootParams?: boolean
 }): Promise<{ result?: TypeCheckResult; version: string | null }> {
   const tsConfigFileName = tsconfigPath || 'tsconfig.json'
   const resolvedTsConfigPath = path.join(dir, tsConfigFileName)
@@ -133,7 +131,6 @@ export async function verifyAndRunTypeScript({
           hasAppDir,
           strictRouteTypes,
           typedRoutes,
-          rootParams: !!rootParams,
         })
 
         return { version: null }
@@ -217,7 +214,6 @@ export async function verifyAndRunTypeScript({
       hasAppDir,
       strictRouteTypes,
       typedRoutes,
-      rootParams: !!rootParams,
     })
 
     let result
diff --git a/packages/next/src/server/.vercel.approvers b/packages/next/src/server/.vercel.approvers
deleted file mode 100644
index f22d7dcea72b..000000000000
--- a/packages/next/src/server/.vercel.approvers
+++ /dev/null
@@ -1,8 +0,0 @@
-config.ts               @timneutkens:notify
-config.ts               @ijjk:notify
-config.ts               @shuding:notify
-config.ts               @huozhi:notify
-serve-static.ts         @timneutkens:notify
-serve-static.ts         @ijjk:notify
-serve-static.ts         @shuding:notify
-serve-static.ts         @huozhi:notify
diff --git a/packages/next/src/server/config-schema.ts b/packages/next/src/server/config-schema.ts
index 72cf0849feae..dcda307a385c 100644
--- a/packages/next/src/server/config-schema.ts
+++ b/packages/next/src/server/config-schema.ts
@@ -762,6 +762,7 @@ export const configSchema: zod.ZodType<NextConfig> = z.lazy(() =>
       .record(z.string(), z.array(z.string()))
       .optional(),
     pageExtensions: z.array(z.string()).min(1).optional(),
+    instrumentationClientInject: z.array(z.string()).optional(),
     poweredByHeader: z.boolean().optional(),
     productionBrowserSourceMaps: z.boolean().optional(),
     reactCompiler: z.union([
diff --git a/packages/next/src/server/config-shared.ts b/packages/next/src/server/config-shared.ts
index 72c7610e105e..a56de95104e2 100644
--- a/packages/next/src/server/config-shared.ts
+++ b/packages/next/src/server/config-shared.ts
@@ -1196,11 +1196,6 @@ export interface ExperimentalConfig {
         showSourceLocation?: boolean
       }
 
-  /**
-   * Enable accessing root params via the `next/root-params` module.
-   */
-  rootParams?: boolean
-
   /**
    * Body size limit for request bodies with middleware configured.
    * Defaults to 10MB. Can be specified as a number (bytes) or string (e.g. '5mb').
@@ -1527,6 +1522,13 @@ export interface NextConfig {
   /** @see [Including non-page files in the pages directory](https://nextjs.org/docs/app/api-reference/config/next-config-js/pageExtensions) */
   pageExtensions?: string[]
 
+  /**
+   * Module specifiers that are required for side effects on the client before
+   * hydration, in array order, ahead of the user's `instrumentation-client.{ts,js}`.
+   * Each entry may be a bare npm package name or a path relative to the project root.
+   */
+  instrumentationClientInject?: string[]
+
   /** @see [Compression documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/compress) */
   compress?: boolean
 
@@ -1874,6 +1876,7 @@ export const defaultConfig = Object.freeze({
   generateBuildId: () => null,
   generateEtags: true,
   pageExtensions: ['tsx', 'ts', 'jsx', 'js'],
+  instrumentationClientInject: [],
   poweredByHeader: true,
   compress: true,
   images: imageConfigDefault,
diff --git a/packages/next/src/server/config.ts b/packages/next/src/server/config.ts
index 2c4827f7abdd..4125151a83d5 100644
--- a/packages/next/src/server/config.ts
+++ b/packages/next/src/server/config.ts
@@ -180,6 +180,13 @@ function checkDeprecations(
     silent
   )
 
+  warnOptionHasBeenDeprecated(
+    userConfig,
+    'experimental.rootParams',
+    `\`experimental.rootParams\` is no longer needed, because \`next/root-params\` is available by default. You can remove it from ${configFileName}.`,
+    silent
+  )
+
   warnOptionHasBeenDeprecated(
     userConfig,
     'eslint',
diff --git a/packages/next/src/server/lib/router-utils/root-params-type-utils.ts b/packages/next/src/server/lib/router-utils/root-params-type-utils.ts
index 8729d6cd17c8..953a21fd4cdf 100644
--- a/packages/next/src/server/lib/router-utils/root-params-type-utils.ts
+++ b/packages/next/src/server/lib/router-utils/root-params-type-utils.ts
@@ -1,7 +1,6 @@
 import fs from 'fs'
 import path from 'path'
 import type { RouteTypesManifest } from './route-types-utils'
-import type { NextConfigComplete } from '../../config-shared'
 
 export type RootParamValueType = 'string' | 'string[]' | 'undefined'
 
@@ -45,24 +44,15 @@ function getRootParamReturnType(valueTypes: RootParamInfo): string {
 }
 
 /**
- * Writes root-params type definitions to a file if the feature is enabled
- * and root params were collected from layouts.
+ * Writes root-params type definitions to a file if root params were collected
+ * from layouts.
  */
 export async function writeRootParamsTypes(
   manifest: RouteTypesManifest,
-  filePath: string,
-  config: NextConfigComplete
+  filePath: string
 ) {
   const rootParams = manifest.rootParams
 
-  const featureEnabled =
-    !!config.experimental.rootParams || !!config.cacheComponents
-
-  if (!featureEnabled) {
-    await fs.promises.rm(filePath, { force: true })
-    return
-  }
-
   await fs.promises.mkdir(path.dirname(filePath), { recursive: true })
 
   if (!rootParams.size) {
diff --git a/packages/next/src/server/lib/router-utils/setup-dev-bundler.ts b/packages/next/src/server/lib/router-utils/setup-dev-bundler.ts
index 504ce9c4953c..d91df07f43cb 100644
--- a/packages/next/src/server/lib/router-utils/setup-dev-bundler.ts
+++ b/packages/next/src/server/lib/router-utils/setup-dev-bundler.ts
@@ -165,9 +165,6 @@ async function verifyTypeScript(opts: SetupOpts) {
     hasPagesDir: !!opts.pagesDir,
     appDir: opts.appDir,
     pagesDir: opts.pagesDir,
-    rootParams:
-      !!opts.nextConfig.experimental.rootParams ||
-      !!opts.nextConfig.cacheComponents,
   })
 
   if (verifyResult.version) {
@@ -1200,8 +1197,7 @@ async function startWatcher(
 
           await writeRootParamsTypes(
             routeTypesManifest,
-            path.join(distTypesDir, 'root-params.d.ts'),
-            opts.nextConfig
+            path.join(distTypesDir, 'root-params.d.ts')
           )
         }
 
diff --git a/packages/next/src/server/lib/trace/tracer.ts b/packages/next/src/server/lib/trace/tracer.ts
index b7ffe39cf32b..8866835fd73e 100644
--- a/packages/next/src/server/lib/trace/tracer.ts
+++ b/packages/next/src/server/lib/trace/tracer.ts
@@ -250,6 +250,14 @@ class NextTracerImpl implements NextTracer {
   ): T {
     const activeContext = context.active()
 
+    if (
+      !NEXT_OTEL_PERFORMANCE_PREFIX &&
+      !this.isTracingEnabled() &&
+      !trace.getSpanContext(activeContext)
+    ) {
+      return fn()
+    }
+
     if (force) {
       const remoteContext = propagation.extract(ROOT_CONTEXT, carrier, getter)
 
diff --git a/packages/next/src/server/next.ts b/packages/next/src/server/next.ts
index c9e2a0af88f8..adf3cc25b4d1 100644
--- a/packages/next/src/server/next.ts
+++ b/packages/next/src/server/next.ts
@@ -149,10 +149,13 @@ export class NextServer implements NextWrapperServer {
       res: ServerResponse,
       parsedUrl?: NextUrlWithParsedQuery
     ) => {
-      return getTracer().trace(NextServerSpan.getRequestHandler, async () => {
-        const requestHandler = await this.getServerRequestHandler()
-        return requestHandler(req, res, parsedUrl)
-      })
+      const tracer = getTracer()
+      return tracer.withPropagatedContext(req.headers, () =>
+        tracer.trace(NextServerSpan.getRequestHandler, async () => {
+          const requestHandler = await this.getServerRequestHandler()
+          return requestHandler(req, res, parsedUrl)
+        })
+      )
     }
   }
 
@@ -166,13 +169,13 @@ export class NextServer implements NextWrapperServer {
       res: ServerResponse,
       parsedUrl?: NextUrlWithParsedQuery
     ) => {
-      return getTracer().trace(
-        NextServerSpan.getRequestHandlerWithMetadata,
-        async () => {
+      const tracer = getTracer()
+      return tracer.withPropagatedContext(req.headers, () =>
+        tracer.trace(NextServerSpan.getRequestHandlerWithMetadata, async () => {
           const server = await this.getServer()
           const handler = server.getRequestHandlerWithMetadata(meta)
           return handler(req, res, parsedUrl)
-        }
+        })
       )
     }
   }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index edaec9faea43..d953ad71ae8d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2004,6 +2004,9 @@ importers:
       inquirer:
         specifier: ^9.2.7
         version: 9.2.23
+      jstat:
+        specifier: ^1.9.6
+        version: 1.9.6
       minimist:
         specifier: ^1.2.8
         version: 1.2.8
@@ -12360,6 +12363,9 @@ packages:
     resolution: {integrity: sha512-4Dj8Rf+fQ+/Pn7C5qeEX02op1WfOss3PKTE9Nsop3Dx+6UPxlm1dr/og7o2cRa5hNN07CACr4NFzRLtj/rjWog==}
     engines: {'0': node >=0.6.0}
 
+  jstat@1.9.6:
+    resolution: {integrity: sha512-rPBkJbK2TnA8pzs93QcDDPlKcrtZWuuCo2dVR0TFLOJSxhqfWOVCSp8aV3/oSbn+4uY4yw1URtLpHQedtmXfug==}
+
   jsx-ast-utils@3.3.5:
     resolution: {integrity: sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==}
     engines: {node: '>=4.0'}
@@ -16519,6 +16525,7 @@ packages:
 
   sliced@1.0.1:
     resolution: {integrity: sha512-VZBmZP8WU3sMOZm1bdgTadsQbcscK0UM8oKxKVBs4XAhUo2Xxzm/OFMGBkPusxw9xL3Uy8LrzEqGqJhclsr0yA==}
+    deprecated: Unsupported
 
   slide@1.1.6:
     resolution: {integrity: sha512-NwrtjCg+lZoqhFU8fOwl4ay2ei8PaqCBOUV3/ektPY9trO1yQ1oXEfmHAhKArUVUr/hOHvy5f6AdP17dCM0zMw==}
@@ -17963,11 +17970,11 @@ packages:
 
   uuid@2.0.3:
     resolution: {integrity: sha512-FULf7fayPdpASncVy4DLh3xydlXEJJpvIELjYjNeQWYUZ9pclcpvCZSr2gkmN2FrrGcI7G/cJsIEwk5/8vfXpg==}
-    deprecated: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
 
   uuid@3.3.3:
     resolution: {integrity: sha512-pW0No1RGHgzlpHJO1nsVrHKpOEIxkGg1xB+v0ZmdNH5OAeAwzAVrCnI2/6Mtx+Uys6iaylxa+D3g4j63IKKjSQ==}
-    deprecated: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
     hasBin: true
 
   uuid@8.3.2:
@@ -23774,7 +23781,7 @@ snapshots:
     dependencies:
       '@typescript-eslint/tsconfig-utils': 8.46.0(typescript@6.0.2)
       '@typescript-eslint/types': 8.46.0
-      debug: 4.4.0
+      debug: 4.4.3
       typescript: 6.0.2
     transitivePeerDependencies:
       - supports-color
@@ -23798,7 +23805,7 @@ snapshots:
       '@typescript-eslint/types': 8.46.0
       '@typescript-eslint/typescript-estree': 8.46.0(typescript@6.0.2)
       '@typescript-eslint/utils': 8.46.0(eslint@9.37.0(jiti@2.6.1))(typescript@6.0.2)
-      debug: 4.4.0
+      debug: 4.4.3
       eslint: 9.37.0(jiti@2.6.1)
       ts-api-utils: 2.1.0(typescript@6.0.2)
       typescript: 6.0.2
@@ -27337,7 +27344,7 @@ snapshots:
 
   esbuild-register@3.6.0(esbuild@0.25.9):
     dependencies:
-      debug: 4.4.0
+      debug: 4.4.3
       esbuild: 0.25.9
     transitivePeerDependencies:
       - supports-color
@@ -30863,6 +30870,8 @@ snapshots:
       json-schema: 0.2.3
       verror: 1.10.0
 
+  jstat@1.9.6: {}
+
   jsx-ast-utils@3.3.5:
     dependencies:
       array-includes: 3.1.8
diff --git a/test/development/acceptance-app/rsc-build-errors.test.ts b/test/development/acceptance-app/rsc-build-errors.test.ts
index fc816123aba2..5a7545837dd7 100644
--- a/test/development/acceptance-app/rsc-build-errors.test.ts
+++ b/test/development/acceptance-app/rsc-build-errors.test.ts
@@ -371,9 +371,7 @@ describe('Error overlay - RSC build errors', () => {
   })
 
   describe('next/root-params', () => {
-    const isCacheComponentsEnabled =
-      process.env.__NEXT_CACHE_COMPONENTS === 'true'
-    it("importing 'next/root-params' when experimental.rootParams is not enabled", async () => {
+    it("importing a non-existent getter from 'next/root-params'", async () => {
       await using sandbox = await createSandbox(
         next,
         undefined,
@@ -381,16 +379,13 @@ describe('Error overlay - RSC build errors', () => {
       )
       const { session } = sandbox
       await session.waitForRedbox()
-      if (!isCacheComponentsEnabled) {
+      if (isTurbopack) {
         expect(await session.getRedboxSource()).toInclude(
-          `'next/root-params' can only be imported when \`experimental.rootParams\` is enabled.`
+          `Export whatever doesn't exist in target module`
         )
       } else {
-        // in cacheComponents we auto-enable 'next/root-params', so we should get an error about using a non-existent getter instead.
-        expect(await session.getRedboxSource()).toInclude(
-          isTurbopack
-            ? `Export whatever doesn't exist in target module`
-            : `Attempted import error: 'whatever' is not exported from 'next/root-params' (imported as 'whatever').`
+        expect(await session.getRedboxDescription()).toInclude(
+          `whatever) is not a function`
         )
       }
     })
@@ -398,17 +393,7 @@ describe('Error overlay - RSC build errors', () => {
     it("importing 'next/root-params' in a client component", async () => {
       await using sandbox = await createSandbox(
         next,
-        // if cacheComponents is not enabled, the import is guarded behind an experimental flag
-        isCacheComponentsEnabled
-          ? new Map()
-          : new Map([
-              [
-                'next.config.js',
-                outdent`
-                  module.exports = { experimental: { rootParams: true } }
-                `,
-              ],
-            ]),
+        undefined,
         `/server-with-errors/next-root-params/in-client`
       )
       const { session } = sandbox
@@ -421,17 +406,7 @@ describe('Error overlay - RSC build errors', () => {
     it("importing 'next/root-params' in a client component in a way that bypasses import analysis", async () => {
       await using sandbox = await createSandbox(
         next,
-        // if cacheComponents is not enabled, the import is guarded behind an experimental flag
-        isCacheComponentsEnabled
-          ? new Map()
-          : new Map([
-              [
-                'next.config.js',
-                outdent`
-                  module.exports = { experimental: { rootParams: true } }
-                `,
-              ],
-            ]),
+        undefined,
         `/server-with-errors/next-root-params/in-client-await-import`
       )
       const { session } = sandbox
diff --git a/test/development/acceptance/server-component-compiler-errors-in-pages.test.ts b/test/development/acceptance/server-component-compiler-errors-in-pages.test.ts
index b46cf8d215cc..36e95ed4856d 100644
--- a/test/development/acceptance/server-component-compiler-errors-in-pages.test.ts
+++ b/test/development/acceptance/server-component-compiler-errors-in-pages.test.ts
@@ -306,13 +306,6 @@ describe('Error Overlay for server components compiler errors in pages', () => {
           }
         `,
       ],
-      [
-        // the import is guarded behind an experimental flag
-        'next.config.js',
-        outdent`
-          module.exports = { experimental: { rootParams: true } }
-        `,
-      ],
     ])
     await using sandbox = await createSandbox(next, files)
     const { session } = sandbox
diff --git a/test/development/typescript-app-type-declarations/typescript-app-type-declarations.test.ts b/test/development/typescript-app-type-declarations/typescript-app-type-declarations.test.ts
index 09e96a0dc2c2..4c3c0f2e8e3f 100644
--- a/test/development/typescript-app-type-declarations/typescript-app-type-declarations.test.ts
+++ b/test/development/typescript-app-type-declarations/typescript-app-type-declarations.test.ts
@@ -15,6 +15,7 @@ const nextEnvDts = strictRouteTypes
   ? `/// <reference types="next" />
 /// <reference types="next/image-types/global" />
 import "./.next/dev/types/routes.d.ts";
+import "./.next/dev/types/root-params.d.ts";
 import "./.next/dev/types/cache-life.d.ts";
 import "./.next/dev/types/validator.ts";
 
@@ -24,6 +25,7 @@ import "./.next/dev/types/validator.ts";
   : `/// <reference types="next" />
 /// <reference types="next/image-types/global" />
 import "./.next/dev/types/routes.d.ts";
+import "./.next/dev/types/root-params.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/pages/api-reference/config/typescript for more information.
diff --git a/test/e2e/app-dir/app-root-params-getters/fixtures/generate-static-params-error/next.config.ts b/test/e2e/app-dir/app-root-params-getters/fixtures/generate-static-params-error/next.config.ts
index 6993a945b3c6..e4f5738a310b 100644
--- a/test/e2e/app-dir/app-root-params-getters/fixtures/generate-static-params-error/next.config.ts
+++ b/test/e2e/app-dir/app-root-params-getters/fixtures/generate-static-params-error/next.config.ts
@@ -1,9 +1,5 @@
 import type { NextConfig } from 'next'
 
-const nextConfig: NextConfig = {
-  experimental: {
-    rootParams: true,
-  },
-}
+const nextConfig: NextConfig = {}
 
 export default nextConfig
diff --git a/test/e2e/app-dir/app-root-params-getters/fixtures/generate-static-params/next.config.ts b/test/e2e/app-dir/app-root-params-getters/fixtures/generate-static-params/next.config.ts
index 6f9923b8467f..fa33c7c54f24 100644
--- a/test/e2e/app-dir/app-root-params-getters/fixtures/generate-static-params/next.config.ts
+++ b/test/e2e/app-dir/app-root-params-getters/fixtures/generate-static-params/next.config.ts
@@ -1,7 +1,7 @@
 import type { NextConfig } from 'next'
 
 const nextConfig: NextConfig = {
-  cacheComponents: true, // implies `rootParams: true`.
+  cacheComponents: true,
 }
 
 export default nextConfig
diff --git a/test/e2e/app-dir/app-root-params-getters/fixtures/multiple-roots/next.config.ts b/test/e2e/app-dir/app-root-params-getters/fixtures/multiple-roots/next.config.ts
index 6993a945b3c6..e4f5738a310b 100644
--- a/test/e2e/app-dir/app-root-params-getters/fixtures/multiple-roots/next.config.ts
+++ b/test/e2e/app-dir/app-root-params-getters/fixtures/multiple-roots/next.config.ts
@@ -1,9 +1,5 @@
 import type { NextConfig } from 'next'
 
-const nextConfig: NextConfig = {
-  experimental: {
-    rootParams: true,
-  },
-}
+const nextConfig: NextConfig = {}
 
 export default nextConfig
diff --git a/test/e2e/app-dir/app-root-params-getters/fixtures/simple/next.config.ts b/test/e2e/app-dir/app-root-params-getters/fixtures/simple/next.config.ts
index 6993a945b3c6..e4f5738a310b 100644
--- a/test/e2e/app-dir/app-root-params-getters/fixtures/simple/next.config.ts
+++ b/test/e2e/app-dir/app-root-params-getters/fixtures/simple/next.config.ts
@@ -1,9 +1,5 @@
 import type { NextConfig } from 'next'
 
-const nextConfig: NextConfig = {
-  experimental: {
-    rootParams: true,
-  },
-}
+const nextConfig: NextConfig = {}
 
 export default nextConfig
diff --git a/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-build/next.config.ts b/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-build/next.config.ts
index f9ec19251f03..a4ba114fc0f0 100644
--- a/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-build/next.config.ts
+++ b/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-build/next.config.ts
@@ -3,7 +3,6 @@ import type { NextConfig } from 'next'
 const nextConfig: NextConfig = {
   experimental: {
     useCache: true,
-    rootParams: true,
   },
 }
 
diff --git a/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-dedup/next.config.ts b/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-dedup/next.config.ts
index f9ec19251f03..a4ba114fc0f0 100644
--- a/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-dedup/next.config.ts
+++ b/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-dedup/next.config.ts
@@ -3,7 +3,6 @@ import type { NextConfig } from 'next'
 const nextConfig: NextConfig = {
   experimental: {
     useCache: true,
-    rootParams: true,
   },
 }
 
diff --git a/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-private/next.config.ts b/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-private/next.config.ts
index f9ec19251f03..a4ba114fc0f0 100644
--- a/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-private/next.config.ts
+++ b/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-private/next.config.ts
@@ -3,7 +3,6 @@ import type { NextConfig } from 'next'
 const nextConfig: NextConfig = {
   experimental: {
     useCache: true,
-    rootParams: true,
   },
 }
 
diff --git a/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-runtime/next.config.ts b/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-runtime/next.config.ts
index f9ec19251f03..a4ba114fc0f0 100644
--- a/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-runtime/next.config.ts
+++ b/test/e2e/app-dir/app-root-params-getters/fixtures/use-cache-runtime/next.config.ts
@@ -3,7 +3,6 @@ import type { NextConfig } from 'next'
 const nextConfig: NextConfig = {
   experimental: {
     useCache: true,
-    rootParams: true,
   },
 }
 
diff --git a/test/e2e/app-dir/ppr-root-param-rsc-fallback/next.config.js b/test/e2e/app-dir/ppr-root-param-rsc-fallback/next.config.js
index 74b8350cb508..e64bae22d658 100644
--- a/test/e2e/app-dir/ppr-root-param-rsc-fallback/next.config.js
+++ b/test/e2e/app-dir/ppr-root-param-rsc-fallback/next.config.js
@@ -3,9 +3,6 @@
  */
 const nextConfig = {
   cacheComponents: true,
-  experimental: {
-    rootParams: true,
-  },
 }
 
 module.exports = nextConfig
diff --git a/test/e2e/app-dir/segment-cache/cached-navigations/app/with-fallback-params/[slug]/layout.tsx b/test/e2e/app-dir/segment-cache/cached-navigations/app/with-fallback-params/[slug]/layout.tsx
deleted file mode 100644
index 836805e6038e..000000000000
--- a/test/e2e/app-dir/segment-cache/cached-navigations/app/with-fallback-params/[slug]/layout.tsx
+++ /dev/null
@@ -1,22 +0,0 @@
-import Link from 'next/link'
-import { ReactNode } from 'react'
-
-export default function ParamsLayout({ children }: { children: ReactNode }) {
-  return (
-    <>
-      <ul>
-        <li>
-          <Link href="/with-fallback-params/foo" prefetch={false}>
-            /with-fallback-params/foo
-          </Link>
-        </li>
-        <li>
-          <Link href="/with-fallback-params/bar" prefetch={false}>
-            /with-fallback-params/bar
-          </Link>
-        </li>
-      </ul>
-      {children}
-    </>
-  )
-}
diff --git a/test/e2e/app-dir/segment-cache/cached-navigations/app/with-fallback-params/layout.tsx b/test/e2e/app-dir/segment-cache/cached-navigations/app/with-fallback-params/layout.tsx
new file mode 100644
index 000000000000..fcc69c74f16d
--- /dev/null
+++ b/test/e2e/app-dir/segment-cache/cached-navigations/app/with-fallback-params/layout.tsx
@@ -0,0 +1,51 @@
+'use client'
+
+import Link from 'next/link'
+import { useRouter } from 'next/navigation'
+import { ReactNode } from 'react'
+import { LinkAccordion } from '../../components/link-accordion'
+
+export default function ParamsLayout({ children }: { children: ReactNode }) {
+  const { bfcacheId } = useRouter()
+
+  return (
+    <>
+      <ul>
+        <li>
+          <Link href="/with-fallback-params" prefetch={false}>
+            /with-fallback-params
+          </Link>
+        </li>
+        <li>
+          <Link href="/with-fallback-params/foo" prefetch={false}>
+            /with-fallback-params/foo
+          </Link>
+        </li>
+        <li>
+          <Link href="/with-fallback-params/bar" prefetch={false}>
+            /with-fallback-params/bar
+          </Link>
+        </li>
+        <li>
+          <LinkAccordion
+            key={bfcacheId}
+            href="/with-fallback-params/foo"
+            prefetch={true}
+          >
+            /with-fallback-params/foo (prefetch=true)
+          </LinkAccordion>
+        </li>
+        <li>
+          <LinkAccordion
+            key={bfcacheId}
+            href="/with-fallback-params/bar"
+            prefetch={true}
+          >
+            /with-fallback-params/bar (prefetch=true)
+          </LinkAccordion>
+        </li>
+      </ul>
+      {children}
+    </>
+  )
+}
diff --git a/test/e2e/app-dir/segment-cache/cached-navigations/app/with-fallback-params/page.tsx b/test/e2e/app-dir/segment-cache/cached-navigations/app/with-fallback-params/page.tsx
new file mode 100644
index 000000000000..2dcc5a7d10d4
--- /dev/null
+++ b/test/e2e/app-dir/segment-cache/cached-navigations/app/with-fallback-params/page.tsx
@@ -0,0 +1,3 @@
+export default function FallbackParamsHub() {
+  return <h1>Fallback Params Hub</h1>
+}
diff --git a/test/e2e/app-dir/segment-cache/cached-navigations/cached-navigations.test.ts b/test/e2e/app-dir/segment-cache/cached-navigations/cached-navigations.test.ts
index 95c7e234bceb..fdfb8197e8e1 100644
--- a/test/e2e/app-dir/segment-cache/cached-navigations/cached-navigations.test.ts
+++ b/test/e2e/app-dir/segment-cache/cached-navigations/cached-navigations.test.ts
@@ -935,4 +935,58 @@ describe('cached navigations', () => {
       'Dynamic content'
     )
   })
+
+  it('does not leak resolved param-specific content across params when using prefetch={true}', async () => {
+    let page: Playwright.Page
+    const browser = await next.browser('/with-fallback-params', {
+      beforePageLoad(p: Playwright.Page) {
+        page = p
+      },
+    })
+    const act = createRouterAct(page)
+
+    // 1. Unveil the foo link. With prefetch={true} this triggers a Full
+    //    dynamic prefetch that returns the fully rendered page.
+    await act(async () => {
+      await browser
+        .elementByCss('input[data-link-accordion="/with-fallback-params/foo"]')
+        .click()
+    })
+
+    // 2. Navigate to /with-fallback-params/foo using the prefetched data.
+    await act(async () => {
+      await browser.elementByCss('a[href="/with-fallback-params/foo"]').click()
+    }, 'no-requests')
+    await retry(async () => {
+      expect(await browser.elementById('params-boundary').text()).toBe(
+        'Param: foo'
+      )
+    })
+
+    // 3. Return to the hub via the layout's back link.
+    await browser.elementByCss('a[href="/with-fallback-params"]')?.click()
+    await retry(async () => {
+      expect(await browser.elementByCss('h1').text()).toBe(
+        'Fallback Params Hub'
+      )
+    })
+
+    // 4. Unveil the bar link.
+    await act(async () => {
+      await browser
+        .elementByCss('input[data-link-accordion="/with-fallback-params/bar"]')
+        .click()
+    })
+
+    // 5. Navigate to /with-fallback-params/bar; should render bar's content
+    //    (sourced from the bar prefetch in step 4), not foo's.
+    await act(async () => {
+      await browser.elementByCss('a[href="/with-fallback-params/bar"]').click()
+    }, 'no-requests')
+    await retry(async () => {
+      const barContent = await browser.elementById('params-boundary').text()
+      expect(barContent).toBe('Param: bar')
+      expect(barContent).not.toContain('foo')
+    })
+  })
 })
diff --git a/test/e2e/app-dir/segment-cache/cached-navigations/components/link-accordion.tsx b/test/e2e/app-dir/segment-cache/cached-navigations/components/link-accordion.tsx
new file mode 100644
index 000000000000..fd8f6781732e
--- /dev/null
+++ b/test/e2e/app-dir/segment-cache/cached-navigations/components/link-accordion.tsx
@@ -0,0 +1,33 @@
+'use client'
+
+import Link, { LinkProps } from 'next/link'
+import { useState } from 'react'
+
+export function LinkAccordion({
+  href,
+  children,
+  prefetch,
+}: {
+  href: string
+  children: React.ReactNode
+  prefetch?: LinkProps['prefetch']
+}) {
+  const [isVisible, setIsVisible] = useState(false)
+  return (
+    <>
+      <input
+        type="checkbox"
+        checked={isVisible}
+        onChange={() => setIsVisible(!isVisible)}
+        data-link-accordion={href}
+      />
+      {isVisible ? (
+        <Link href={href} prefetch={prefetch}>
+          {children}
+        </Link>
+      ) : (
+        `${children} (link is hidden)`
+      )}
+    </>
+  )
+}
diff --git a/test/e2e/instrumentation-client-hook/inject/app/layout.tsx b/test/e2e/instrumentation-client-hook/inject/app/layout.tsx
new file mode 100644
index 000000000000..568b8766b221
--- /dev/null
+++ b/test/e2e/instrumentation-client-hook/inject/app/layout.tsx
@@ -0,0 +1,19 @@
+import Link from 'next/link'
+
+export default function RootLayout({ children }) {
+  return (
+    <html>
+      <body>
+        <ul>
+          <li>
+            <Link href="/">Home</Link>
+          </li>
+          <li>
+            <Link href="/some-page">Some Page</Link>
+          </li>
+        </ul>
+        {children}
+      </body>
+    </html>
+  )
+}
diff --git a/test/e2e/instrumentation-client-hook/inject/app/page.tsx b/test/e2e/instrumentation-client-hook/inject/app/page.tsx
new file mode 100644
index 000000000000..113324caa66e
--- /dev/null
+++ b/test/e2e/instrumentation-client-hook/inject/app/page.tsx
@@ -0,0 +1,3 @@
+export default function Page() {
+  return <h1 id="home">Home</h1>
+}
diff --git a/test/e2e/instrumentation-client-hook/inject/app/some-page/page.tsx b/test/e2e/instrumentation-client-hook/inject/app/some-page/page.tsx
new file mode 100644
index 000000000000..8c6bb6df3ca6
--- /dev/null
+++ b/test/e2e/instrumentation-client-hook/inject/app/some-page/page.tsx
@@ -0,0 +1,3 @@
+export default function Page() {
+  return <h1 id="some-page">Some page</h1>
+}
diff --git a/test/e2e/instrumentation-client-hook/inject/inject-a.js b/test/e2e/instrumentation-client-hook/inject/inject-a.js
new file mode 100644
index 000000000000..ec97b40782f5
--- /dev/null
+++ b/test/e2e/instrumentation-client-hook/inject/inject-a.js
@@ -0,0 +1,8 @@
+window.__INJECT_ORDER = window.__INJECT_ORDER || []
+window.__INJECT_ORDER.push('a')
+window.__INJECT_A_EXECUTED_AT = performance.now()
+
+export function onRouterTransitionStart(href, navigateType) {
+  const pathname = new URL(href, window.location.href).pathname
+  console.log(`[Router Transition Start] [${navigateType}] ${pathname} a`)
+}
diff --git a/test/e2e/instrumentation-client-hook/inject/inject-b.js b/test/e2e/instrumentation-client-hook/inject/inject-b.js
new file mode 100644
index 000000000000..e19537614c5e
--- /dev/null
+++ b/test/e2e/instrumentation-client-hook/inject/inject-b.js
@@ -0,0 +1,8 @@
+window.__INJECT_ORDER = window.__INJECT_ORDER || []
+window.__INJECT_ORDER.push('b')
+window.__INJECT_B_EXECUTED_AT = performance.now()
+
+export function onRouterTransitionStart(href, navigateType) {
+  const pathname = new URL(href, window.location.href).pathname
+  console.log(`[Router Transition Start] [${navigateType}] ${pathname} b`)
+}
diff --git a/test/e2e/instrumentation-client-hook/inject/instrumentation-client.ts b/test/e2e/instrumentation-client-hook/inject/instrumentation-client.ts
new file mode 100644
index 000000000000..6a82ba52b6e6
--- /dev/null
+++ b/test/e2e/instrumentation-client-hook/inject/instrumentation-client.ts
@@ -0,0 +1,8 @@
+;(window as any).__INJECT_ORDER = (window as any).__INJECT_ORDER || []
+;(window as any).__INJECT_ORDER.push('user')
+;(window as any).__INSTRUMENTATION_CLIENT_EXECUTED_AT = performance.now()
+
+export function onRouterTransitionStart(href: string, navigateType: string) {
+  const pathname = new URL(href, window.location.href).pathname
+  console.log(`[Router Transition Start] [${navigateType}] ${pathname} user`)
+}
diff --git a/test/e2e/instrumentation-client-hook/inject/next.config.js b/test/e2e/instrumentation-client-hook/inject/next.config.js
new file mode 100644
index 000000000000..ee32e6ca3fed
--- /dev/null
+++ b/test/e2e/instrumentation-client-hook/inject/next.config.js
@@ -0,0 +1,4 @@
+/** @type {import('next').NextConfig} */
+module.exports = {
+  instrumentationClientInject: ['./inject-a.js', './inject-b.js'],
+}
diff --git a/test/e2e/instrumentation-client-hook/instrumentation-client-hook.test.ts b/test/e2e/instrumentation-client-hook/instrumentation-client-hook.test.ts
index b47db90edecb..2a03659e432c 100644
--- a/test/e2e/instrumentation-client-hook/instrumentation-client-hook.test.ts
+++ b/test/e2e/instrumentation-client-hook/instrumentation-client-hook.test.ts
@@ -1,4 +1,4 @@
-import { nextTestSetup } from 'e2e-utils'
+import { isNextDev, nextTestSetup } from 'e2e-utils'
 import { retry } from 'next-test-utils'
 import path from 'path'
 
@@ -49,21 +49,21 @@ describe('Instrumentation Client Hook', () => {
     })
   })
 
+  function filterNavigationStartLogs(logs: Array<{ message: string }>) {
+    const result = []
+    for (const log of logs) {
+      if (log.message.startsWith('[Router Transition Start]')) {
+        result.push(log.message)
+      }
+    }
+    return result
+  }
+
   describe('onRouterTransitionStart', () => {
     const { next } = nextTestSetup({
       files: path.join(__dirname, 'app-router'),
     })
 
-    function filterNavigationStartLogs(logs: Array<{ message: string }>) {
-      const result = []
-      for (const log of logs) {
-        if (log.message.startsWith('[Router Transition Start]')) {
-          result.push(log.message)
-        }
-      }
-      return result
-    }
-
     it('onRouterTransitionStart fires at the start of a navigation', async () => {
       const browser = await next.browser('/')
 
@@ -102,12 +102,62 @@ describe('Instrumentation Client Hook', () => {
     })
   })
 
-  describe('HMR in development mode', () => {
-    const { next, isNextDev } = nextTestSetup({
-      files: path.join(__dirname, 'app-router'),
+  describe('instrumentationClientInject', () => {
+    const { next } = nextTestSetup({
+      files: path.join(__dirname, 'inject'),
     })
 
-    if (isNextDev) {
+    it('runs each injected entry before the user instrumentation-client and before hydration, in array order', async () => {
+      const browser = await next.browser('/')
+
+      const order = await browser.eval(`window.__INJECT_ORDER`)
+      expect(order).toEqual(['a', 'b', 'user'])
+
+      const injectA = await browser.eval(`window.__INJECT_A_EXECUTED_AT`)
+      const injectB = await browser.eval(`window.__INJECT_B_EXECUTED_AT`)
+      const userTime = await browser.eval(
+        `window.__INSTRUMENTATION_CLIENT_EXECUTED_AT`
+      )
+      const hydrationTime = await browser.eval(`window.__NEXT_HYDRATED_AT`)
+
+      expect(injectA).toBeDefined()
+      expect(injectB).toBeDefined()
+      expect(userTime).toBeDefined()
+      expect(hydrationTime).toBeDefined()
+
+      expect(injectA).toBeLessThanOrEqual(injectB)
+      expect(injectB).toBeLessThanOrEqual(userTime)
+      expect(userTime).toBeLessThan(hydrationTime)
+    })
+
+    it('still surfaces onRouterTransitionStart from the user instrumentation-client when injects are configured', async () => {
+      const browser = await next.browser('/')
+
+      const linkToSomePage = await browser.elementByCss('a[href="/some-page"]')
+      await linkToSomePage.click()
+      await browser.elementById('some-page')
+
+      const linkToHome = await browser.elementByCss('a[href="/"]')
+      await linkToHome.click()
+      await browser.elementById('home')
+
+      expect(filterNavigationStartLogs(await browser.log())).toEqual([
+        '[Router Transition Start] [push] /some-page a',
+        '[Router Transition Start] [push] /some-page b',
+        '[Router Transition Start] [push] /some-page user',
+        '[Router Transition Start] [push] / a',
+        '[Router Transition Start] [push] / b',
+        '[Router Transition Start] [push] / user',
+      ])
+    })
+  })
+
+  if (isNextDev) {
+    describe('HMR in development mode', () => {
+      const { next } = nextTestSetup({
+        files: path.join(__dirname, 'app-router'),
+      })
+
       it('should reload instrumentation-client when modified', async () => {
         const browser = await next.browser('/')
         const initialTime = await browser.eval(
@@ -146,13 +196,6 @@ describe('Instrumentation Client Hook', () => {
         // Restore the original file
         await next.patchFile(instrumentationPath, originalContent)
       })
-    } else {
-      // Add a dummy test when not in dev mode
-      it('skips tests in non-dev mode', () => {
-        console.log(
-          'Skipping instrumentation-client-hook tests in non-dev mode'
-        )
-      })
-    }
-  })
+    })
+  }
 })
diff --git a/test/e2e/opentelemetry/instrumentation/opentelemetry.test.ts b/test/e2e/opentelemetry/instrumentation/opentelemetry.test.ts
index fa07de919651..525eda27ea6b 100644
--- a/test/e2e/opentelemetry/instrumentation/opentelemetry.test.ts
+++ b/test/e2e/opentelemetry/instrumentation/opentelemetry.test.ts
@@ -1159,6 +1159,74 @@ describe('opentelemetry', () => {
     )
   }
 })
+;(process.env.__NEXT_CACHE_COMPONENTS ? describe.skip : describe)(
+  'opentelemetry NEXT_OTEL_VERBOSE=1',
+  () => {
+    const { next, skipped } = nextTestSetup({
+      files: __dirname,
+      skipDeployment: true,
+      dependencies: require('./package.json').dependencies,
+      env: {
+        TEST_OTEL_COLLECTOR_PORT: String(COLLECTOR_PORT),
+        NEXT_TELEMETRY_DISABLED: '1',
+        NEXT_OTEL_VERBOSE: '1',
+      },
+    })
+
+    if (skipped) {
+      return
+    }
+
+    let collector: Collector | undefined
+
+    beforeEach(async () => {
+      collector = await connectCollector({ port: COLLECTOR_PORT })
+    })
+
+    afterEach(async () => {
+      await collector?.shutdown()
+      collector = undefined
+    })
+
+    // Regression for https://github.com/vercel/otel/issues/107.
+    it('all spans (including verbose) inherit traceId from incoming traceparent header', async () => {
+      const pathname = '/app/param/rsc-fetch'
+      await next.fetch(pathname, {
+        headers: {
+          traceparent: `00-${EXTERNAL.traceId}-${EXTERNAL.spanId}-01`,
+        },
+      })
+
+      let spans: SavedSpan[] = []
+      await retry(async () => {
+        const all = collector?.getSpans() ?? []
+        const root = all.find(
+          (s) =>
+            s.attributes?.['next.span_type'] === 'BaseServer.handleRequest' &&
+            s.attributes?.['http.target'] === pathname
+        )
+        expect(root).toBeDefined()
+        expect(root!.traceId).toBe(EXTERNAL.traceId)
+
+        spans = all.filter((s) => s.traceId === root!.traceId)
+        expect(spans.length).toBeGreaterThan(1)
+
+        const verbose = spans.find(
+          (s) =>
+            s.attributes?.['next.span_type'] === 'NextServer.getRequestHandler'
+        )
+        expect(verbose).toBeDefined()
+        expect(verbose!.traceId).toBe(EXTERNAL.traceId)
+        const parentSpanId = verbose!.parentId
+        expect(parentSpanId).toBe(EXTERNAL.spanId)
+      })
+
+      for (const span of spans) {
+        expect(span.traceId).toBe(EXTERNAL.traceId)
+      }
+    })
+  }
+)
 
 describe('opentelemetry with disabled fetch tracing', () => {
   const { next, skipped } = nextTestSetup({
diff --git a/test/production/app-dir/generate-static-params-errors/next.config.ts b/test/production/app-dir/generate-static-params-errors/next.config.ts
index 42500be934ae..e4f5738a310b 100644
--- a/test/production/app-dir/generate-static-params-errors/next.config.ts
+++ b/test/production/app-dir/generate-static-params-errors/next.config.ts
@@ -1,7 +1,5 @@
 import type { NextConfig } from 'next'
 
-const nextConfig: NextConfig = {
-  experimental: { rootParams: true },
-}
+const nextConfig: NextConfig = {}
 
 export default nextConfig
diff --git a/test/rspack-dev-tests-manifest.json b/test/rspack-dev-tests-manifest.json
index 25c92af64619..d5427fce2ab8 100644
--- a/test/rspack-dev-tests-manifest.json
+++ b/test/rspack-dev-tests-manifest.json
@@ -225,7 +225,7 @@
       "Error overlay - RSC build errors importing 'next/cache' APIs in a client component unstable_noStore is allowed",
       "Error overlay - RSC build errors next/root-params importing 'next/root-params' in a client component",
       "Error overlay - RSC build errors next/root-params importing 'next/root-params' in a client component in a way that bypasses import analysis",
-      "Error overlay - RSC build errors next/root-params importing 'next/root-params' when experimental.rootParams is not enabled",
+      "Error overlay - RSC build errors next/root-params importing a non-existent getter from 'next/root-params'",
       "Error overlay - RSC build errors should allow to use and handle rsc poisoning client-only",
       "Error overlay - RSC build errors should allow to use and handle rsc poisoning server-only",
       "Error overlay - RSC build errors should error for invalid undefined module retuning from next dynamic",
diff --git a/test/unit/write-app-declarations.test.ts b/test/unit/write-app-declarations.test.ts
index f82b8887a7c4..24e4f7246a67 100644
--- a/test/unit/write-app-declarations.test.ts
+++ b/test/unit/write-app-declarations.test.ts
@@ -24,6 +24,8 @@ describe('find config', () => {
         : '') +
       `import "./.next/types/routes.d.ts";` +
       eol +
+      `import "./.next/types/root-params.d.ts";` +
+      eol +
       eol +
       '// NOTE: This file should not be edited' +
       eol +
@@ -40,7 +42,6 @@ describe('find config', () => {
       hasAppDir: false,
       strictRouteTypes: false,
       typedRoutes: true,
-      rootParams: false,
     })
     expect(await fs.readFile(declarationFile, 'utf8')).toBe(content)
   })
@@ -55,6 +56,8 @@ describe('find config', () => {
         : '') +
       `import "./.next/types/routes.d.ts";` +
       eol +
+      `import "./.next/types/root-params.d.ts";` +
+      eol +
       eol +
       '// NOTE: This file should not be edited' +
       eol +
@@ -71,7 +74,6 @@ describe('find config', () => {
       hasAppDir: false,
       strictRouteTypes: false,
       typedRoutes: true,
-      rootParams: false,
     })
     expect(await fs.readFile(declarationFile, 'utf8')).toBe(content)
   })
@@ -86,6 +88,8 @@ describe('find config', () => {
         : '') +
       `import "./.next/types/routes.d.ts";` +
       eol +
+      `import "./.next/types/root-params.d.ts";` +
+      eol +
       eol +
       '// NOTE: This file should not be edited' +
       eol +
@@ -100,7 +104,6 @@ describe('find config', () => {
       hasAppDir: false,
       strictRouteTypes: false,
       typedRoutes: true,
-      rootParams: false,
     })
     expect(await fs.readFile(declarationFile, 'utf8')).toBe(content)
   })
@@ -114,7 +117,6 @@ describe('find config', () => {
       hasAppDir: true,
       strictRouteTypes: false,
       typedRoutes: true,
-      rootParams: false,
     })
 
     await expect(fs.readFile(declarationFile, 'utf8')).resolves.not.toContain(
@@ -129,7 +131,6 @@ describe('find config', () => {
       hasAppDir: true,
       strictRouteTypes: false,
       typedRoutes: true,
-      rootParams: false,
     })
 
     await expect(fs.readFile(declarationFile, 'utf8')).resolves.toContain(
diff --git a/turbopack/packages/devlow-bench/package.json b/turbopack/packages/devlow-bench/package.json
index 2c2776792b31..5be176caba24 100644
--- a/turbopack/packages/devlow-bench/package.json
+++ b/turbopack/packages/devlow-bench/package.json
@@ -45,6 +45,7 @@
   "dependencies": {
     "@datadog/datadog-api-client": "^1.13.0",
     "inquirer": "^9.2.7",
+    "jstat": "^1.9.6",
     "minimist": "^1.2.8",
     "picocolors": "1.0.1",
     "pidusage-tree": "^2.0.5",
diff --git a/turbopack/packages/devlow-bench/src/cli.ts b/turbopack/packages/devlow-bench/src/cli.ts
index cc3ca16e4cb7..53f1743df0f8 100644
--- a/turbopack/packages/devlow-bench/src/cli.ts
+++ b/turbopack/packages/devlow-bench/src/cli.ts
@@ -3,8 +3,60 @@ import { setCurrentScenarios } from './describe.js'
 import { join } from 'path'
 import { Scenario, ScenarioVariant, runScenarios } from './index.js'
 import compose from './interfaces/compose.js'
+import { groupRows, printComparison } from './compare.js'
+import { readSnapshot, resolveCompareTarget } from './snapshot.js'
 import { pathToFileURL } from 'url'
+
+const SUBCOMMANDS = new Set(['run', 'compare'])
+
 ;(async () => {
+  // Subcommand dispatch. `devlow-bench run [opts] scenario.mjs` and
+  // `devlow-bench compare <a.csv> <b.csv>` are the explicit forms. A bare
+  // `devlow-bench <script>` falls through to legacy run-mode for back-compat.
+  const argv = process.argv.slice(2)
+  const first = argv[0]
+  const sub = first && SUBCOMMANDS.has(first) ? first : 'run'
+  const rest = first && SUBCOMMANDS.has(first) ? argv.slice(1) : argv
+
+  if (sub === 'compare') {
+    await runCompareSubcommand(rest)
+    return
+  }
+  await runRunSubcommand(rest)
+})().catch((e) => {
+  console.error(e.stack)
+  process.exit(1)
+})
+
+async function runCompareSubcommand(argv: string[]): Promise<void> {
+  const args = minimist(argv, {
+    alias: { '?': 'help', h: 'help' },
+  })
+  if (args.help || args._.length === 0) {
+    console.log(`Usage: devlow-bench compare <baseline.csv> <current.csv>
+  Reads both snapshot CSVs and prints a side-by-side comparison table
+  with mean/p50/p90 plus Welch’s t and Mann–Whitney U p-values per metric.`)
+    if (args.help) return
+  }
+  if (args._.length !== 2) {
+    console.error(
+      `devlow-bench compare: expected 2 positional CSV paths, got ${args._.length}.`
+    )
+    console.error('Usage: devlow-bench compare <baseline.csv> <current.csv>')
+    process.exit(1)
+  }
+  const [baselinePath, currentPath] = args._
+  const [baseRows, curRows] = await Promise.all([
+    readSnapshot(baselinePath),
+    readSnapshot(currentPath),
+  ])
+  printComparison(groupRows(baseRows), groupRows(curRows), {
+    baselineLabel: baselinePath,
+    currentLabel: currentPath,
+  })
+}
+
+async function runRunSubcommand(argv: string[]): Promise<void> {
   const knownArgs = new Set([
     'scenario',
     's',
@@ -15,12 +67,17 @@ import { pathToFileURL } from 'url'
     'snowflake',
     'interactive',
     'i',
+    'n',
+    'warmup',
+    'snapshot',
+    'compare',
+    'baseline',
     'help',
     'h',
     '?',
     '_',
   ])
-  const args = minimist(process.argv.slice(2), {
+  const args = minimist(argv, {
     alias: {
       s: 'scenario',
       j: 'json',
@@ -28,41 +85,40 @@ import { pathToFileURL } from 'url'
       '?': 'help',
       h: 'help',
     },
+    // `compare` is strictly a boolean toggle now (use --baseline=<path> for
+    // the value form). Declaring it here prevents `--compare scenario.mjs`
+    // from consuming the scenario as the flag value.
+    boolean: ['compare'],
   })
 
   if (args.help || (Object.keys(args).length === 1 && args._.length === 0)) {
-    console.log('Usage: devlow-bench [options] <scenario files>')
-    console.log('## Selecting scenarios')
-    console.log(
-      '  --scenario=<filter>, -s=<filter>   Only run the scenario with the given name'
-    )
-    console.log(
-      '  --interactive, -i                  Select scenarios and variants interactively'
-    )
-    console.log(
-      '  --<prop>=<value>                   Filter by any variant property defined in scenarios'
-    )
-    console.log('## Output')
-    console.log(
-      '  --json=<path>, -j=<path>           Write the results to the given path as JSON'
-    )
-    console.log(
-      '  --console                          Print the results to the console'
-    )
-    console.log(
-      '  --datadog[=<hostname>]             Upload the results to Datadog'
-    )
-    console.log(
-      '                                     (requires DATADOG_API_KEY environment variables)'
-    )
-    console.log(
-      '  --snowflake[=<batch-uri>]          Upload the results to Snowflake'
-    )
-    console.log(
-      '                                     (requires SNOWFLAKE_TOPIC_NAME and SNOWFLAKE_SCHEMA_ID and environment variables)'
-    )
-    console.log('## Help')
-    console.log('  --help, -h, -?                     Show this help')
+    console.log(`Usage: devlow-bench [run] [options] <scenario files>
+       devlow-bench compare <baseline.csv> <current.csv>
+## Selecting scenarios
+  --scenario=<filter>, -s=<filter>   Only run the scenario with the given name
+  --interactive, -i                  Select scenarios and variants interactively
+  --<prop>=<value>                   Filter by any variant property defined in scenarios
+## Repeated sampling
+  --n=<number>                       Run each variant N times. Reports mean/p50/p90 per metric.
+                                     Default: 1.
+  --warmup=<number>                  Discard the first N runs of each variant before sampling.
+                                     Default: 0. Do NOT enable when measuring cold-start metrics.
+## Snapshots & comparison
+  --snapshot=<path>                  Override the snapshot CSV path.
+                                     Default: ./.devlow-bench/snapshots/<ts>.csv. Snapshots are always written.
+  --compare                          Print a comparison table at end of run. Baseline = newest snapshot,
+                                     unless --baseline overrides.
+  --baseline=<path>                  Explicit baseline (file or directory). Implies --compare.
+## Output
+  --json=<path>, -j=<path>           Write the results to the given path as JSON
+  --console                          Print the results to the console
+  --datadog[=<hostname>]             Upload the results to Datadog
+                                     (requires DATADOG_API_KEY environment variables)
+  --snowflake[=<batch-uri>]          Upload the results to Snowflake
+                                     (requires SNOWFLAKE_TOPIC_NAME and SNOWFLAKE_SCHEMA_ID and environment variables)
+## Help
+  --help, -h, -?                     Show this help`)
+    if (args.help) return
   }
 
   const scenarios: Scenario[] = []
@@ -103,10 +159,46 @@ import { pathToFileURL } from 'url'
       return variants
     },
   }
+  // Validation (clamp to non-negative integers, default n=1/warmup=0) is
+  // delegated to runScenarios — see runner.ts.
+  const n = typeof args.n === 'number' ? args.n : 1
+  const warmup = typeof args.warmup === 'number' ? args.warmup : 0
+
+  // Snapshot is always on. `--snapshot=<path>` overrides the default path.
+  const snapshotPath =
+    typeof args.snapshot === 'string' ? args.snapshot : undefined
+  const snapshotIface = (await import('./interfaces/snapshot.js')).default({
+    path: snapshotPath,
+  })
+
+  // Comparison: enabled by either --compare (boolean) or --baseline=<path>.
+  // The baseline is the value of --baseline if given, else "auto" (newest
+  // snapshot in the default snapshot dir).
+  const compareEnabled =
+    args.compare === true || typeof args.baseline === 'string'
+  let compareIface: any = null
+  if (compareEnabled) {
+    const baselineArg = typeof args.baseline === 'string' ? args.baseline : true
+    const baselinePath = await resolveCompareTarget(
+      baselineArg,
+      snapshotIface.resolvedPath
+    )
+    if (baselinePath == null) {
+      console.error(
+        'No baseline snapshot found. Run devlow-bench at least once, or pass --baseline=<path>.'
+      )
+      process.exit(1)
+    }
+    compareIface = await (
+      await import('./interfaces/compare.js')
+    ).default({ baselinePath })
+  }
+
   let ifaces = [
     cliIface,
     args.interactive && (await import('./interfaces/interactive.js')).default(),
-    args.json && (await import('./interfaces/json.js')).default(args.json),
+    args.json &&
+      (await import('./interfaces/json.js')).default(args.json, { n }),
     args.datadog &&
       (await import('./interfaces/datadog.js')).default(
         typeof args.datadog === 'string' ? { host: args.datadog } : undefined
@@ -118,10 +210,9 @@ import { pathToFileURL } from 'url'
           : undefined
       ),
     args.console !== false &&
-      (await import('./interfaces/console.js')).default(),
+      (await import('./interfaces/console.js')).default({ n }),
+    compareIface,
+    snapshotIface,
   ].filter((x) => x)
-  await runScenarios(scenarios, compose(...ifaces))
-})().catch((e) => {
-  console.error(e.stack)
-  process.exit(1)
-})
+  await runScenarios(scenarios, compose(...ifaces), { n, warmup })
+}
diff --git a/turbopack/packages/devlow-bench/src/compare.ts b/turbopack/packages/devlow-bench/src/compare.ts
new file mode 100644
index 000000000000..8dd2f3e1048b
--- /dev/null
+++ b/turbopack/packages/devlow-bench/src/compare.ts
@@ -0,0 +1,227 @@
+import picocolors from 'picocolors'
+import { SnapshotRow } from './snapshot.js'
+import { mannWhitneyU, summary, welchsTTest } from './statistics.js'
+import { formatUnit } from './units.js'
+
+const { bold, dim, green, red, underline } = picocolors
+
+const SIGNIFICANCE_THRESHOLD = 0.05
+
+type RowVerdict = 'improved' | 'regressed' | undefined
+
+interface FormattedRow {
+  cells: string[]
+  verdict: RowVerdict
+}
+
+export interface SampleGroup {
+  scenario: string
+  variant: string
+  metric: string
+  unit: string
+  samples: number[]
+}
+
+// Groups SnapshotRows into per-(scenario, variant, metric) sample arrays.
+// Skips rows whose value is non-finite (e.g. failed CSV parse).
+export function groupRows(rows: SnapshotRow[]): Map<string, SampleGroup> {
+  const out = new Map<string, SampleGroup>()
+  for (const r of rows) {
+    if (!Number.isFinite(r.value)) continue
+    const key = makeKey(r.scenario, r.variant, r.metric)
+    let group = out.get(key)
+    if (!group) {
+      group = {
+        scenario: r.scenario,
+        variant: r.variant,
+        metric: r.metric,
+        unit: r.unit,
+        samples: [],
+      }
+      out.set(key, group)
+    }
+    group.samples.push(r.value)
+  }
+  return out
+}
+
+export function makeKey(
+  scenario: string,
+  variant: string,
+  metric: string
+): string {
+  return `${scenario}\x00${variant}\x00${metric}`
+}
+
+// Prints the comparison table comparing baseline (A) to current (B).
+// Reports series only in one side and unit mismatches separately.
+export function printComparison(
+  baseline: Map<string, SampleGroup>,
+  current: Map<string, SampleGroup>,
+  options: { baselineLabel: string; currentLabel?: string } = {
+    baselineLabel: 'baseline',
+  }
+): void {
+  const { baselineLabel, currentLabel } = options
+  console.log()
+  if (currentLabel) {
+    console.log(
+      bold(underline(`Comparison: ${baselineLabel} → ${currentLabel}`))
+    )
+  } else {
+    console.log(bold(underline(`Comparison vs baseline: ${baselineLabel}`)))
+  }
+
+  const rows: FormattedRow[] = []
+  const onlyInCurrent: string[] = []
+  const onlyInBaseline: string[] = []
+  const skippedMismatch: string[] = []
+
+  for (const [key, cur] of current) {
+    const base = baseline.get(key)
+    if (!base) {
+      onlyInCurrent.push(`${cur.scenario} · ${cur.variant} · ${cur.metric}`)
+      continue
+    }
+    if (base.unit !== cur.unit) {
+      skippedMismatch.push(
+        `${cur.scenario} · ${cur.variant} · ${cur.metric} (baseline=${base.unit}, current=${cur.unit})`
+      )
+      continue
+    }
+    rows.push(formatRow(base, cur))
+  }
+  for (const [key, base] of baseline) {
+    if (!current.has(key)) {
+      onlyInBaseline.push(`${base.scenario} · ${base.variant} · ${base.metric}`)
+    }
+  }
+
+  if (rows.length > 0) {
+    const header = [
+      'Scenario · Variant',
+      'Metric',
+      'Baseline μ / p50 / p90 (n)',
+      'Current μ / p50 / p90 (n)',
+      'Δ mean',
+      'Δ%',
+      "Welch's p",
+      'MWU p',
+    ]
+    printTable(header, rows)
+  } else {
+    console.log(
+      dim(
+        'No matching (scenario, variant, metric) tuples between current and baseline.'
+      )
+    )
+  }
+
+  logList('Only in current', onlyInCurrent)
+  logList('Only in baseline', onlyInBaseline)
+  logList('Skipped due to unit mismatch', skippedMismatch, Infinity)
+}
+
+function logList(label: string, items: string[], max: number = 5): void {
+  if (items.length === 0) return
+  const shown = items.slice(0, max).join(', ')
+  const suffix = items.length > max ? '…' : ''
+  console.log(dim(`${label} (${items.length}): ${shown}${suffix}`))
+}
+
+function formatRow(base: SampleGroup, cur: SampleGroup): FormattedRow {
+  const bs = summary(base.samples)
+  const cs = summary(cur.samples)
+  const delta = cs.mean - bs.mean
+  const deltaPct = bs.mean === 0 ? NaN : (delta / bs.mean) * 100
+  const welchs = welchsTTest(base.samples, cur.samples)
+  const mwu = mannWhitneyU(base.samples, cur.samples)
+  // Color verdict uses Welch's p as the primary signal.
+  let verdict: RowVerdict
+  if (
+    Number.isFinite(welchs.p) &&
+    welchs.p < SIGNIFICANCE_THRESHOLD &&
+    delta !== 0
+  ) {
+    verdict = delta < 0 ? 'improved' : 'regressed'
+  }
+  return {
+    cells: [
+      `${base.scenario} · ${base.variant}`,
+      base.metric,
+      formatGroupCell(base, bs),
+      formatGroupCell(cur, cs),
+      formatDelta(delta, base.unit),
+      Number.isFinite(deltaPct) ? `${deltaPct.toFixed(1)}%` : 'n/a',
+      formatP(welchs.p),
+      formatP(mwu.p),
+    ],
+    verdict,
+  }
+}
+
+function formatGroupCell(
+  group: SampleGroup,
+  s: { mean: number; p50: number; p90: number }
+): string {
+  const parts = [s.mean, s.p50, s.p90].map((v) =>
+    splitFormattedUnit(v, group.unit)
+  )
+  const n = group.samples.length
+  // If all three values render with the same unit suffix (e.g. all "requests"),
+  // only print the suffix on the last value to avoid "7 req / 7 req / 7 req".
+  if (
+    parts[0].suffix === parts[1].suffix &&
+    parts[1].suffix === parts[2].suffix
+  ) {
+    return `${parts[0].num} / ${parts[1].num} / ${parts[2].num}${parts[2].suffix} (${n})`
+  }
+  return `${parts[0].num}${parts[0].suffix} / ${parts[1].num}${parts[1].suffix} / ${parts[2].num}${parts[2].suffix} (${n})`
+}
+
+function splitFormattedUnit(
+  value: number,
+  unit: string
+): { num: string; suffix: string } {
+  const formatted = formatUnit(value, unit)
+  const m = /^(-?\d+(?:\.\d+)?)(.*)$/.exec(formatted)
+  if (!m) return { num: formatted, suffix: '' }
+  return { num: m[1], suffix: m[2] }
+}
+
+function formatDelta(d: number, unit: string): string {
+  if (!Number.isFinite(d)) return 'n/a'
+  const sign = d > 0 ? '+' : ''
+  return `${sign}${formatUnit(d, unit)}`
+}
+
+function formatP(p: number): string {
+  if (!Number.isFinite(p)) return String(p)
+  if (p === 0) return '0'
+  if (p < 1e-3) return p.toExponential(2)
+  return p.toFixed(3)
+}
+
+function printTable(header: string[], rows: FormattedRow[]) {
+  const widths = header.map((h) => h.length)
+  for (const r of rows) {
+    for (let i = 0; i < r.cells.length; i++) {
+      if (r.cells[i].length > widths[i]) widths[i] = r.cells[i].length
+    }
+  }
+  const pad = (s: string, w: number) => s + ' '.repeat(w - s.length)
+  const line = (cells: string[], paint: (s: string) => string = (s) => s) =>
+    '| ' + cells.map((c, i) => paint(pad(c, widths[i]))).join(' | ') + ' |'
+  const sep = '|' + widths.map((w) => '-'.repeat(w + 2)).join('|') + '|'
+  console.log(line(header))
+  console.log(sep)
+  for (const r of rows) {
+    const paint =
+      r.verdict === 'improved'
+        ? green
+        : r.verdict === 'regressed'
+          ? red
+          : undefined
+    console.log(line(r.cells, paint))
+  }
+}
diff --git a/turbopack/packages/devlow-bench/src/index.ts b/turbopack/packages/devlow-bench/src/index.ts
index 361ddb94e420..da87038dfe45 100644
--- a/turbopack/packages/devlow-bench/src/index.ts
+++ b/turbopack/packages/devlow-bench/src/index.ts
@@ -35,6 +35,15 @@ export interface CurrentScenario {
 
 export type Interface = Partial<FullInterface>
 
+export interface VariantStatistic {
+  samples: number[]
+  unit: string
+  relativeTo?: string
+  mean: number
+  p50: number
+  p90: number
+}
+
 export interface FullInterface {
   filterScenarios(scenarios: Scenario[]): Promise<Scenario[]>
   filterScenarioVariants(
@@ -43,7 +52,8 @@ export interface FullInterface {
 
   start(
     scenario: string,
-    props: Record<string, string | number | boolean | null>
+    props: Record<string, string | number | boolean | null>,
+    runInfo?: { run: number; total: number; warmup: boolean }
   ): Promise<void>
   measurement(
     scenario: string,
@@ -63,6 +73,13 @@ export interface FullInterface {
     error: unknown
   ): Promise<void>
 
+  // Called once per variant after all n runs complete, with per-metric stats.
+  variantStatistics(
+    scenario: string,
+    props: Record<string, string | number | boolean | null>,
+    stats: Record<string, VariantStatistic>
+  ): Promise<void>
+
   finish(): Promise<void>
 }
 
@@ -76,6 +93,7 @@ export function intoFullInterface(iface: Interface): FullInterface {
     measurement: iface.measurement ?? (async () => {}),
     end: iface.end ?? (async () => {}),
     error: iface.error ?? (async () => {}),
+    variantStatistics: iface.variantStatistics ?? (async () => {}),
     finish: iface.finish ?? (async () => {}),
   }
 }
diff --git a/turbopack/packages/devlow-bench/src/interfaces/compare.ts b/turbopack/packages/devlow-bench/src/interfaces/compare.ts
new file mode 100644
index 000000000000..83a75a37e0ce
--- /dev/null
+++ b/turbopack/packages/devlow-bench/src/interfaces/compare.ts
@@ -0,0 +1,32 @@
+import { Interface } from '../index.js'
+import { SampleGroup, groupRows, makeKey, printComparison } from '../compare.js'
+import { readSnapshot } from '../snapshot.js'
+import { formatVariantProps } from '../utils.js'
+
+export default async function createInterface(options: {
+  baselinePath: string
+}): Promise<Interface> {
+  const baselinePath = options.baselinePath
+  const baselineRows = await readSnapshot(baselinePath)
+  const baseline = groupRows(baselineRows)
+  const current = new Map<string, SampleGroup>()
+
+  return {
+    variantStatistics: async (scenario, props, stats) => {
+      const variant = formatVariantProps(props)
+      for (const [metric, s] of Object.entries(stats)) {
+        const key = makeKey(scenario, variant, metric)
+        current.set(key, {
+          scenario,
+          variant,
+          metric,
+          unit: s.unit,
+          samples: s.samples.slice(),
+        })
+      }
+    },
+    finish: async () => {
+      printComparison(baseline, current, { baselineLabel: baselinePath })
+    },
+  }
+}
diff --git a/turbopack/packages/devlow-bench/src/interfaces/console.ts b/turbopack/packages/devlow-bench/src/interfaces/console.ts
index 06471bd7f875..915703150434 100644
--- a/turbopack/packages/devlow-bench/src/interfaces/console.ts
+++ b/turbopack/packages/devlow-bench/src/interfaces/console.ts
@@ -3,14 +3,23 @@ import { Interface } from '../index.js'
 import { formatUnit } from '../units.js'
 import { formatVariant } from '../utils.js'
 
-const { bgCyan, bold, magenta, red, underline } = picocolors
+const { bgCyan, bold, cyan, dim, magenta, red, underline } = picocolors
 
-export default function createInterface(): Interface {
+export default function createInterface(
+  options: { n?: number } = {}
+): Interface {
+  const n = options.n ?? 1
+  const showSummary = n > 1
   const iface: Interface = {
-    start: async (scenario, props) => {
-      console.log(
-        bold(underline(`Running ${formatVariant(scenario, props)}...`))
-      )
+    start: async (scenario, props, runInfo) => {
+      const label = formatVariant(scenario, props)
+      let progress = ''
+      if (runInfo) {
+        progress = runInfo.warmup
+          ? ` [warmup ${runInfo.run}/${runInfo.total}]`
+          : ` [${runInfo.run}/${runInfo.total}]`
+      }
+      console.log(bold(underline(`Running ${label}...${progress}`)))
     },
     measurement: async (scenario, props, name, value, unit, relativeTo) => {
       console.log(
@@ -26,6 +35,20 @@ export default function createInterface(): Interface {
         )
       )
     },
+    variantStatistics: async (scenario, props, stats) => {
+      if (!showSummary) return
+      const header = `${formatVariant(scenario, props)}  (n=${n})`
+      console.log(bold(cyan(header)))
+      for (const [name, s] of Object.entries(stats)) {
+        const meanText = formatUnit(s.mean, s.unit)
+        const p50Text = formatUnit(s.p50, s.unit)
+        const p90Text = formatUnit(s.p90, s.unit)
+        const relText = s.relativeTo ? dim(` (from ${s.relativeTo})`) : ''
+        console.log(
+          `  ${name}: mean=${meanText}  p50=${p50Text}  p90=${p90Text}${relText}`
+        )
+      }
+    },
     error: async (scenario, props, error) => {
       console.log(
         bold(
diff --git a/turbopack/packages/devlow-bench/src/interfaces/json.ts b/turbopack/packages/devlow-bench/src/interfaces/json.ts
index 1b68053c342f..26eac2dfaccd 100644
--- a/turbopack/packages/devlow-bench/src/interfaces/json.ts
+++ b/turbopack/packages/devlow-bench/src/interfaces/json.ts
@@ -1,4 +1,5 @@
 import { Interface } from '../index.js'
+import { quantile, mean as statsMean } from '../statistics.js'
 import { formatUnit } from '../units.js'
 import { writeFile } from 'fs/promises'
 
@@ -21,15 +22,17 @@ export default function createInterface(
       throw new Error('env var JSON_OUTPUT_FILE is not set')
     }
     return file
-  })()
+  })(),
+  options: { n?: number } = {}
 ): Interface {
+  const n = options.n ?? 1
+  // Per-(scenario, props, name) sample accumulator.
   const metrics = new Map<
     string,
     {
       key: Record<string, string | number>
-      value: number
+      samples: number[]
       unit: string
-      count: number
       relativeTo?: string
     }
   >()
@@ -43,36 +46,47 @@ export default function createInterface(
       const key = JSON.stringify(keyObject)
       const current = metrics.get(key)
       if (current) {
-        current.value += value
-        current.count++
+        current.samples.push(value)
       } else {
         metrics.set(key, {
           key: keyObject,
-          value,
-          unit: unit,
-          count: 1,
+          samples: [value],
+          unit,
           relativeTo,
         })
       }
     },
     finish: async () => {
-      await writeFile(
-        file,
-        JSON.stringify(
-          [...metrics.values()].map(
-            ({ key, value, unit, count, relativeTo }) => {
-              return {
-                key,
-                value: value / count,
-                unit,
-                text: formatUnit(value / count, unit),
-                datapoints: count,
-                relativeTo,
-              }
+      const results = [...metrics.values()].map(
+        ({ key, samples, unit, relativeTo }) => {
+          if (samples.length === 1) {
+            // Preserve the original single-run shape exactly for back-compat.
+            return {
+              key,
+              value: samples[0],
+              unit,
+              text: formatUnit(samples[0], unit),
+              datapoints: 1,
+              relativeTo,
             }
-          )
-        )
+          }
+          const m = statsMean(samples)
+          return {
+            key,
+            value: m,
+            unit,
+            text: formatUnit(m, unit),
+            datapoints: samples.length,
+            mean: m,
+            p50: quantile(samples, 0.5),
+            p90: quantile(samples, 0.9),
+            samples,
+            relativeTo,
+          }
+        }
       )
+      const payload = n > 1 ? { results } : (results as unknown)
+      await writeFile(file, JSON.stringify(payload))
     },
   }
 
diff --git a/turbopack/packages/devlow-bench/src/interfaces/snapshot.ts b/turbopack/packages/devlow-bench/src/interfaces/snapshot.ts
new file mode 100644
index 000000000000..a7e2b7fc49b0
--- /dev/null
+++ b/turbopack/packages/devlow-bench/src/interfaces/snapshot.ts
@@ -0,0 +1,68 @@
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import picocolors from 'picocolors'
+import { Interface } from '../index.js'
+import { SnapshotRow, defaultSnapshotPath, writeSnapshot } from '../snapshot.js'
+import { formatVariantProps } from '../utils.js'
+
+const execFileAsync = promisify(execFile)
+
+async function readGitInfo(): Promise<{ sha: string; branch: string }> {
+  const sha = process.env.GITHUB_SHA || (await tryGit(['rev-parse', 'HEAD']))
+  const branch =
+    process.env.GITHUB_REF_NAME ||
+    (await tryGit(['rev-parse', '--abbrev-ref', 'HEAD']))
+  return { sha, branch }
+}
+
+async function tryGit(args: string[]): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync('git', args)
+    return stdout.trim()
+  } catch {
+    return ''
+  }
+}
+
+export default function createInterface(
+  options: { path?: string } = {}
+): Interface & { resolvedPath: string } {
+  const path = options.path ?? defaultSnapshotPath()
+  const rows: SnapshotRow[] = []
+  const timestamp = new Date().toISOString()
+
+  const iface: Interface & { resolvedPath: string } = {
+    resolvedPath: path,
+    variantStatistics: async (scenario, props, stats) => {
+      const variant = formatVariantProps(props)
+      for (const [metric, s] of Object.entries(stats)) {
+        for (let i = 0; i < s.samples.length; i++) {
+          rows.push({
+            timestamp,
+            scenario,
+            variant,
+            metric,
+            sample_idx: i + 1,
+            value: s.samples[i],
+            unit: s.unit,
+            relative_to: s.relativeTo ?? '',
+            git_sha: '',
+            git_branch: '',
+          })
+        }
+      }
+    },
+    finish: async () => {
+      if (rows.length === 0) return
+      const { sha, branch } = await readGitInfo()
+      for (const r of rows) {
+        r.git_sha = sha
+        r.git_branch = branch
+      }
+      await writeSnapshot(path, rows)
+      console.log(picocolors.dim(`Wrote ${rows.length} rows to ${path}`))
+    },
+  }
+
+  return iface
+}
diff --git a/turbopack/packages/devlow-bench/src/jstat.d.ts b/turbopack/packages/devlow-bench/src/jstat.d.ts
new file mode 100644
index 000000000000..9c7f852c70da
--- /dev/null
+++ b/turbopack/packages/devlow-bench/src/jstat.d.ts
@@ -0,0 +1,9 @@
+// Minimal ambient declarations for `jstat` (no TypeScript types shipped).
+// Only the distribution CDFs used by src/statistics.ts are declared.
+declare module 'jstat' {
+  const jstat: {
+    studentt: { cdf(x: number, dof: number): number }
+    normal: { cdf(x: number, mean: number, sd: number): number }
+  }
+  export default jstat
+}
diff --git a/turbopack/packages/devlow-bench/src/runner.ts b/turbopack/packages/devlow-bench/src/runner.ts
index 42f375871adc..f68833080589 100644
--- a/turbopack/packages/devlow-bench/src/runner.ts
+++ b/turbopack/packages/devlow-bench/src/runner.ts
@@ -1,10 +1,26 @@
 import { withCurrent } from './describe.js'
-import { Interface, Scenario, intoFullInterface } from './index.js'
+import {
+  FullInterface,
+  Interface,
+  Scenario,
+  VariantStatistic,
+  intoFullInterface,
+} from './index.js'
+import { summary } from './statistics.js'
+
+interface SampleSet {
+  samples: number[]
+  unit: string
+  relativeTo?: string
+}
 
 export async function runScenarios(
   scenarios: Scenario[],
-  iface: Interface
+  iface: Interface,
+  options: { n?: number; warmup?: number } = {}
 ): Promise<void> {
+  const n = Math.max(1, Math.floor(options.n ?? 1))
+  const warmup = Math.max(0, Math.floor(options.warmup ?? 0))
   const fullIface = intoFullInterface(iface)
   if (scenarios.some((scenario) => scenario.only)) {
     scenarios = scenarios.filter((scenario) => scenario.only)
@@ -37,27 +53,96 @@ export async function runScenarios(
   variants = await fullIface.filterScenarioVariants(variants)
 
   for (const variant of variants) {
-    try {
-      const measurements = new Map()
-      await withCurrent(
-        {
-          iface: fullIface,
-          measurements,
-          scenario: variant,
-        },
-        async () => {
-          await fullIface.start(variant.scenario.name, variant.props)
-          measurements.set('start', {
-            value: Date.now(),
-            unit: 'ms',
-          })
-          await variant.scenario.fn(variant.props)
-          await fullIface.end(variant.scenario.name, variant.props)
+    const samplesByMetric = new Map<string, SampleSet>()
+
+    // Wrap the interface for this variant so that per-sample `measurement`
+    // calls (a) flow through to all underlying reporters (preserving Datadog /
+    // Snowflake / etc. behavior) and (b) get collected into samplesByMetric
+    // for aggregation. Only counted on non-warmup runs.
+    let collecting = false
+    const wrappedIface: FullInterface = {
+      ...fullIface,
+      measurement: async (scenario, props, name, value, unit, relativeTo) => {
+        if (collecting) {
+          const existing = samplesByMetric.get(name)
+          if (existing) {
+            existing.samples.push(value)
+          } else {
+            samplesByMetric.set(name, {
+              samples: [value],
+              unit,
+              relativeTo,
+            })
+          }
         }
+        await fullIface.measurement(
+          scenario,
+          props,
+          name,
+          value,
+          unit,
+          relativeTo
+        )
+      },
+    }
+
+    const totalRuns = warmup + n
+    let aborted = false
+    for (let run = 0; run < totalRuns; run++) {
+      collecting = run >= warmup
+      // Only report run progress when the user is actually doing multiple
+      // runs. Single-sample runs don't need a "[1/1]" tag.
+      const runInfo =
+        totalRuns > 1
+          ? run < warmup
+            ? { run: run + 1, total: warmup, warmup: true }
+            : { run: run - warmup + 1, total: n, warmup: false }
+          : undefined
+      try {
+        const measurements = new Map()
+        await withCurrent(
+          {
+            iface: wrappedIface,
+            measurements,
+            scenario: variant,
+          },
+          async () => {
+            await wrappedIface.start(
+              variant.scenario.name,
+              variant.props,
+              runInfo
+            )
+            measurements.set('start', {
+              value: Date.now(),
+              unit: 'ms',
+            })
+            await variant.scenario.fn(variant.props)
+            await wrappedIface.end(variant.scenario.name, variant.props)
+          }
+        )
+      } catch (e) {
+        await wrappedIface.error(variant.scenario.name, variant.props, e)
+        process.exitCode = 1
+        aborted = true
+        break
+      }
+    }
+
+    if (!aborted && samplesByMetric.size > 0) {
+      const stats: Record<string, VariantStatistic> = {}
+      for (const [name, set] of samplesByMetric) {
+        stats[name] = {
+          samples: set.samples,
+          unit: set.unit,
+          relativeTo: set.relativeTo,
+          ...summary(set.samples),
+        }
+      }
+      await fullIface.variantStatistics(
+        variant.scenario.name,
+        variant.props,
+        stats
       )
-    } catch (e) {
-      await fullIface.error(variant.scenario.name, variant.props, e)
-      process.exitCode = 1
     }
   }
 
diff --git a/turbopack/packages/devlow-bench/src/snapshot.ts b/turbopack/packages/devlow-bench/src/snapshot.ts
new file mode 100644
index 000000000000..97b313d74caa
--- /dev/null
+++ b/turbopack/packages/devlow-bench/src/snapshot.ts
@@ -0,0 +1,189 @@
+import { readFile, readdir, mkdir, writeFile, stat } from 'node:fs/promises'
+import { dirname, join, resolve } from 'node:path'
+
+export const DEFAULT_SNAPSHOT_DIR = '.devlow-bench/snapshots'
+
+// One row per (scenario, variant, metric, sample). Long-format so the same
+// file can store mixed-unit metrics (ms, MB, requests, ...) without sparse
+// columns. Consumers can filter by `unit` and pivot downstream.
+export interface SnapshotRow {
+  timestamp: string
+  scenario: string
+  variant: string
+  metric: string
+  sample_idx: number
+  value: number
+  unit: string
+  relative_to: string
+  git_sha: string
+  git_branch: string
+}
+
+const COLUMNS: (keyof SnapshotRow)[] = [
+  'timestamp',
+  'scenario',
+  'variant',
+  'metric',
+  'sample_idx',
+  'value',
+  'unit',
+  'relative_to',
+  'git_sha',
+  'git_branch',
+]
+
+export function defaultSnapshotPath(
+  dir: string = DEFAULT_SNAPSHOT_DIR,
+  now: Date = new Date()
+): string {
+  // ISO-ish, filesystem-safe, lexicographic-sortable.
+  const stamp = now.toISOString().replace(/[:.]/g, '-').replace(/Z$/, 'Z')
+  return resolve(join(dir, `${stamp}.csv`))
+}
+
+export async function writeSnapshot(
+  path: string,
+  rows: SnapshotRow[]
+): Promise<void> {
+  await mkdir(dirname(path), { recursive: true })
+  const lines: string[] = [COLUMNS.join(',')]
+  for (const row of rows) {
+    lines.push(COLUMNS.map((c) => csvCell(row[c])).join(','))
+  }
+  await writeFile(path, lines.join('\n') + '\n')
+}
+
+export async function readSnapshot(path: string): Promise<SnapshotRow[]> {
+  const text = await readFile(path, 'utf-8')
+  const lines = text.split(/\r?\n/).filter((l) => l.length > 0)
+  if (lines.length === 0) return []
+  const header = parseCsvLine(lines[0])
+  const idx: Partial<Record<keyof SnapshotRow, number>> = {}
+  for (let i = 0; i < header.length; i++) {
+    if ((COLUMNS as string[]).includes(header[i])) {
+      idx[header[i] as keyof SnapshotRow] = i
+    }
+  }
+  const rows: SnapshotRow[] = []
+  for (let i = 1; i < lines.length; i++) {
+    const cells = parseCsvLine(lines[i])
+    const get = (k: keyof SnapshotRow): string => {
+      const j = idx[k]
+      return j == null ? '' : (cells[j] ?? '')
+    }
+    rows.push({
+      timestamp: get('timestamp'),
+      scenario: get('scenario'),
+      variant: get('variant'),
+      metric: get('metric'),
+      sample_idx: Number(get('sample_idx')),
+      value: Number(get('value')),
+      unit: get('unit'),
+      relative_to: get('relative_to'),
+      git_sha: get('git_sha'),
+      git_branch: get('git_branch'),
+    })
+  }
+  return rows
+}
+
+// Returns the newest .csv in the directory, excluding the optional exclude
+// path. Returns null if the directory doesn't exist or has no matching files.
+export async function findMostRecentSnapshot(
+  dir: string = DEFAULT_SNAPSHOT_DIR,
+  excludePath?: string
+): Promise<string | null> {
+  let entries: string[]
+  try {
+    entries = await readdir(dir)
+  } catch (e: any) {
+    if (e.code === 'ENOENT') return null
+    throw e
+  }
+  const candidates = entries.filter((f) => f.endsWith('.csv'))
+  const excludeResolved = excludePath ? resolve(excludePath) : null
+  let best: { path: string; mtime: number } | null = null
+  for (const f of candidates) {
+    const full = resolve(join(dir, f))
+    if (excludeResolved && full === excludeResolved) continue
+    const s = await stat(full)
+    if (!best || s.mtimeMs > best.mtime) {
+      best = { path: full, mtime: s.mtimeMs }
+    }
+  }
+  return best?.path ?? null
+}
+
+// Resolve --compare: if given a directory, pick the newest .csv inside;
+// if given a file, use it; if null/undefined, fall back to DEFAULT_SNAPSHOT_DIR.
+export async function resolveCompareTarget(
+  target: string | true | undefined,
+  excludePath?: string
+): Promise<string | null> {
+  if (target == null) return null
+  let candidatePath: string | null = null
+  if (target === true) {
+    candidatePath = await findMostRecentSnapshot(
+      DEFAULT_SNAPSHOT_DIR,
+      excludePath
+    )
+  } else {
+    let isDir = false
+    try {
+      isDir = (await stat(target)).isDirectory()
+    } catch {
+      // Path doesn't exist; let caller error out.
+    }
+    if (isDir) {
+      candidatePath = await findMostRecentSnapshot(target, excludePath)
+    } else {
+      candidatePath = resolve(target)
+    }
+  }
+  return candidatePath
+}
+
+function csvCell(v: string | number): string {
+  const s = String(v)
+  if (/[,"\n\r]/.test(s)) {
+    return `"${s.replace(/"/g, '""')}"`
+  }
+  return s
+}
+
+function parseCsvLine(line: string): string[] {
+  const cells: string[] = []
+  let i = 0
+  while (i < line.length) {
+    if (line[i] === '"') {
+      let s = ''
+      i++ // skip opening quote
+      while (i < line.length) {
+        if (line[i] === '"') {
+          if (line[i + 1] === '"') {
+            s += '"'
+            i += 2
+          } else {
+            i++ // closing quote
+            break
+          }
+        } else {
+          s += line[i]
+          i++
+        }
+      }
+      cells.push(s)
+      if (line[i] === ',') i++
+    } else {
+      const next = line.indexOf(',', i)
+      if (next === -1) {
+        cells.push(line.slice(i))
+        i = line.length
+      } else {
+        cells.push(line.slice(i, next))
+        i = next + 1
+      }
+    }
+  }
+  return cells
+}
diff --git a/turbopack/packages/devlow-bench/src/statistics-test.ts b/turbopack/packages/devlow-bench/src/statistics-test.ts
new file mode 100644
index 000000000000..c3d21a79b591
--- /dev/null
+++ b/turbopack/packages/devlow-bench/src/statistics-test.ts
@@ -0,0 +1,117 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { mean, quantile, welchsTTest, mannWhitneyU } from './statistics.js'
+
+function near(actual: number, expected: number, tol = 1e-6, label = '') {
+  assert.ok(
+    Math.abs(actual - expected) < tol,
+    `${label}: expected ${expected}, got ${actual} (tol ${tol})`
+  )
+}
+
+test('mean', () => {
+  near(mean([1, 2, 3, 4, 5]), 3)
+  near(mean([10]), 10)
+})
+
+test('quantile (linear interpolation, numpy/R type 7)', () => {
+  // [1,2,3,4,5] with q=0.5 → 3, q=0.9 → 4.6
+  near(quantile([1, 2, 3, 4, 5], 0.5), 3)
+  near(quantile([1, 2, 3, 4, 5], 0.9), 4.6)
+  // sorts internally
+  near(quantile([5, 3, 1, 2, 4], 0.5), 3)
+  // single sample
+  near(quantile([42], 0.9), 42)
+})
+
+test("Welch's t-test: small samples", () => {
+  // Hand-verified: means 2 and 3, both sample variances = 1.
+  //   sea = seb = 1/3, denom = 2/3
+  //   t = -1 / sqrt(2/3) = -1.2247448713915892
+  //   df = (2/3)^2 / (2 * (1/3)^2 / 2) = (4/9) / (1/9) = 4
+  //   p ≈ 0.288 (two-sided, df=4)
+  const r = welchsTTest([1, 2, 3], [2, 3, 4])
+  near(r.t, -1.2247448713915892, 1e-12, 't')
+  near(r.df, 4, 1e-12, 'df')
+  near(r.p, 0.288, 1e-3, 'p')
+})
+
+test("Welch's t-test: large clearly-different samples", () => {
+  // mean_a=12, mean_b=22, var_a=var_b=2.5 → t=-10 exactly, df=8 exactly.
+  const a = [10, 11, 12, 13, 14]
+  const b = [20, 21, 22, 23, 24]
+  const r = welchsTTest(a, b)
+  near(r.t, -10, 1e-12, 't')
+  near(r.df, 8, 1e-12, 'df')
+  // P(|T|>10 | df=8) is on the order of 8e-6.
+  assert.ok(r.p > 1e-6 && r.p < 1e-5, `expected p in (1e-6, 1e-5), got ${r.p}`)
+})
+
+test("Welch's t-test: identical samples → t=0, p=1", () => {
+  const r = welchsTTest([1, 2, 3, 4, 5], [1, 2, 3, 4, 5])
+  near(r.t, 0)
+  near(r.p, 1)
+})
+
+test('Welch handles unequal variance (small group variance)', () => {
+  // [1..5] vs [10, 10.1, 10.2, 10.3, 10.4]
+  // var_a = 2.5, var_b = 0.025 → very unequal.
+  // sea = 0.5, seb = 0.005, denom = 0.505
+  // t = -7.2 / sqrt(0.505) ≈ -10.1318
+  // df = 0.505^2 / (0.0625 + 6.25e-6) ≈ 4.080
+  const r = welchsTTest([1, 2, 3, 4, 5], [10, 10.1, 10.2, 10.3, 10.4])
+  near(r.t, -10.131804644116203, 1e-9, 't')
+  near(r.df, 4.08, 1e-2, 'df')
+  // df is small (~4) so heavier tails than the df=8 case: p should be larger.
+  assert.ok(r.p < 1e-3, `expected p<1e-3, got ${r.p}`)
+})
+
+test('t-distribution CDF: known critical value', () => {
+  // df=10, |t|=2.228 → two-sided p ≈ 0.05 (standard table).
+  // We verify by constructing a sample with exactly that t-stat.
+  // Easier: use the fact that for df=∞ (large df), Welch's reduces to z-test.
+  // df=1000, t≈1.96 should give p≈0.05.
+  // Construct a=[0]*n, b shifted: we can't get exact df without specific values,
+  // so we just confirm the formula gives sane values across df range.
+  // Pair 1: df ≈ 10, t ≈ 2.228 — synthesize with two known groups.
+  // Simpler check: at very large df, p should match the normal-tail p for the same z.
+  const huge = Array.from({ length: 500 }, (_, i) => i)
+  const huger = Array.from({ length: 500 }, (_, i) => i + 0.2) // tiny shift
+  const r = welchsTTest(huge, huger)
+  // With this setup df is enormous (~1000) and t is small but well-defined.
+  // p should be between 0 and 1; finite.
+  assert.ok(Number.isFinite(r.p))
+  assert.ok(r.p >= 0 && r.p <= 1)
+})
+
+test('Mann–Whitney U: n=5 vs n=5, max separation', () => {
+  // [1..5] vs [6..10]: U=0. Exact two-sided p = 2/252 ≈ 0.00794;
+  // asymptotic with continuity correction ≈ 0.012. Both indicate a strong
+  // separation; we just verify U=0 and p is below 0.05.
+  const r = mannWhitneyU([1, 2, 3, 4, 5], [6, 7, 8, 9, 10])
+  assert.equal(r.u, 0)
+  assert.ok(r.p < 0.05, `expected p<0.05, got ${r.p}`)
+  assert.ok(r.p > 0.005, `expected p>0.005, got ${r.p}`)
+})
+
+test('Mann–Whitney U: fully overlapping → no rejection', () => {
+  const r = mannWhitneyU([1, 2, 3], [1, 2, 3])
+  assert.ok(r.p > 0.5, `expected p>0.5, got ${r.p}`)
+})
+
+test('Mann–Whitney U: 3 vs 3 distinct, no ties', () => {
+  // U=0 for group A. Exact two-sided p = 0.1; asymptotic ≈ 0.081.
+  const r = mannWhitneyU([1, 2, 3], [4, 5, 6])
+  assert.equal(r.u, 0)
+  assert.ok(r.p > 0.05 && r.p < 0.15, `expected p in (0.05, 0.15), got ${r.p}`)
+})
+
+test('Mann–Whitney U: medium samples use normal approximation', () => {
+  // Two clearly separated groups of 12.
+  // scipy two-sided p with continuity correction is in the ~1e-5 range.
+  const a = Array.from({ length: 12 }, (_, i) => i + 1)
+  const b = Array.from({ length: 12 }, (_, i) => i + 100)
+  const r = mannWhitneyU(a, b)
+  assert.equal(r.u, 0)
+  assert.ok(r.p < 1e-4, `expected p<1e-4, got ${r.p}`)
+})
diff --git a/turbopack/packages/devlow-bench/src/statistics.ts b/turbopack/packages/devlow-bench/src/statistics.ts
new file mode 100644
index 000000000000..bc221d704df0
--- /dev/null
+++ b/turbopack/packages/devlow-bench/src/statistics.ts
@@ -0,0 +1,138 @@
+// Statistics helpers for repeated-sampling benchmarks.
+//
+// We use `jstat` for the underlying distribution CDFs (Student's t and
+// standard normal). The rest — Welch's t-statistic, average-rank ranking,
+// and the Mann–Whitney U statistic + asymptotic-tail p-value — is
+// implemented here directly.
+//
+// For Mann–Whitney we use the normal approximation with continuity
+// correction. For very small samples this approximation is less accurate
+// (n=5 vs n=5 has a minimum exact two-sided p ≈ 0.008 vs the
+// approximation's ≈ 0.012). Document this at the call site, not here.
+import jstat from 'jstat'
+
+export interface Summary {
+  mean: number
+  p50: number
+  p90: number
+}
+
+export function mean(xs: number[]): number {
+  if (xs.length === 0) return NaN
+  let s = 0
+  for (const x of xs) s += x
+  return s / xs.length
+}
+
+// Linear-interpolation quantile (numpy/R "type 7" default).
+export function quantile(xs: number[], q: number): number {
+  if (xs.length === 0) return NaN
+  if (xs.length === 1) return xs[0]
+  const sorted = [...xs].sort((a, b) => a - b)
+  const pos = q * (sorted.length - 1)
+  const lo = Math.floor(pos)
+  const hi = Math.ceil(pos)
+  if (lo === hi) return sorted[lo]
+  return sorted[lo] + (pos - lo) * (sorted[hi] - sorted[lo])
+}
+
+export function summary(samples: number[]): Summary {
+  return {
+    mean: mean(samples),
+    p50: quantile(samples, 0.5),
+    p90: quantile(samples, 0.9),
+  }
+}
+
+export interface WelchsTResult {
+  t: number
+  df: number
+  p: number
+}
+
+// Two-sample Welch's t-test (unequal variances, two-sided).
+export function welchsTTest(a: number[], b: number[]): WelchsTResult {
+  if (a.length < 2 || b.length < 2) return { t: NaN, df: NaN, p: NaN }
+  if (allEqual(a) && allEqual(b)) {
+    const ma = a[0]
+    const mb = b[0]
+    return {
+      t: ma === mb ? 0 : ma > mb ? Infinity : -Infinity,
+      df: NaN,
+      p: ma === mb ? 1 : 0,
+    }
+  }
+  const ma = mean(a)
+  const mb = mean(b)
+  const va = sampleVariance(a, ma)
+  const vb = sampleVariance(b, mb)
+  const na = a.length
+  const nb = b.length
+  const sea = va / na
+  const seb = vb / nb
+  const t = (ma - mb) / Math.sqrt(sea + seb)
+  // Welch–Satterthwaite degrees of freedom.
+  const df =
+    (sea + seb) ** 2 / ((sea * sea) / (na - 1) + (seb * seb) / (nb - 1))
+  const p = 2 * (1 - jstat.studentt.cdf(Math.abs(t), df))
+  return { t, df, p }
+}
+
+export interface MannWhitneyResult {
+  u: number
+  p: number
+}
+
+// Two-sided Mann–Whitney U test, asymptotic with continuity correction.
+export function mannWhitneyU(a: number[], b: number[]): MannWhitneyResult {
+  const na = a.length
+  const nb = b.length
+  if (na === 0 || nb === 0) return { u: NaN, p: NaN }
+
+  const combined = [...a, ...b]
+  const r = averageRanks(combined)
+  let rankSumA = 0
+  for (let i = 0; i < na; i++) rankSumA += r[i]
+  const uA = rankSumA - (na * (na + 1)) / 2
+  const uB = na * nb - uA
+  const u = Math.min(uA, uB)
+
+  const meanU = (na * nb) / 2
+  const sd = Math.sqrt((na * nb * (na + nb + 1)) / 12)
+  if (sd === 0) return { u, p: 1 }
+  const z = Math.max(0, (Math.abs(uA - meanU) - 0.5) / sd)
+  const p = 2 * (1 - jstat.normal.cdf(z, 0, 1))
+  return { u, p: Math.min(1, Math.max(0, p)) }
+}
+
+// Average-rank ranking (R/scipy default tie correction): tied values share
+// the mean of the ranks they would have received.
+function averageRanks(xs: number[]): number[] {
+  const n = xs.length
+  const idx: [number, number][] = xs.map((v, i) => [v, i])
+  idx.sort((p, q) => p[0] - q[0])
+  const r = new Array<number>(n)
+  let i = 0
+  while (i < n) {
+    let j = i
+    while (j + 1 < n && idx[j + 1][0] === idx[i][0]) j++
+    const avg = (i + j) / 2 + 1
+    for (let k = i; k <= j; k++) r[idx[k][1]] = avg
+    i = j + 1
+  }
+  return r
+}
+
+function sampleVariance(xs: number[], m: number): number {
+  let s = 0
+  for (const x of xs) {
+    const d = x - m
+    s += d * d
+  }
+  return s / (xs.length - 1)
+}
+
+function allEqual(xs: number[]): boolean {
+  for (let i = 1; i < xs.length; i++) if (xs[i] !== xs[0]) return false
+  return true
+}
diff --git a/turbopack/packages/devlow-bench/src/utils.ts b/turbopack/packages/devlow-bench/src/utils.ts
index 72f8c5a89717..3ab917141ccd 100644
--- a/turbopack/packages/devlow-bench/src/utils.ts
+++ b/turbopack/packages/devlow-bench/src/utils.ts
@@ -2,11 +2,16 @@ export function formatVariant(
   scenario: string,
   props: Record<string, string | number | boolean | null>
 ): string {
-  const keys = Object.keys(props)
+  const propsStr = formatVariantProps(props)
+  return propsStr ? `${scenario} ${propsStr}` : scenario
+}
+
+// Just the props part (no scenario prefix). Stable key for snapshots/compare.
+export function formatVariantProps(
+  props: Record<string, string | number | boolean | null>
+): string {
+  return Object.keys(props)
     .filter((key) => props[key] !== false && props[key] !== null)
     .map((key) => (props[key] === true ? key : `${key}=${props[key]}`))
-  if (keys.length === 0) {
-    return scenario
-  }
-  return `${scenario} ${keys.join(' ')}`
+    .join(' ')
 }