Add files using upload-large-folder tool

nextjs-95738-assets-hash-salt/environment/Dockerfile

@@ -0,0 +1,45 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | env RUSTUP_HOME=/usr/local/rustup CARGO_HOME=/usr/local/cargo sh -s -- -y --no-modify-path --profile minimal --default-toolchain 1.90.0
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && NEXT_SKIP_NATIVE_POSTINSTALL=1 pnpm install --frozen-lockfile && PATH="$HOME/.cargo/bin:$PATH" pnpm swc-build-native && pnpm build' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app

nextjs-95738-assets-hash-salt/solution/gold.patch

@@ -0,0 +1,494 @@
+diff --git a/crates/next-api/src/next_server_nft.rs b/crates/next-api/src/next_server_nft.rs
+index 56d1b83ac6cb085133a6c20068764d7df26e8859..972cd0ad6597cdcc3812cbe158fb396604dd5af8 100644
+--- a/crates/next-api/src/next_server_nft.rs
++++ b/crates/next-api/src/next_server_nft.rs
+@@ -115,12 +115,15 @@ impl Asset for ServerNftJsonAsset {
+         )
+         .connect();
+ 
++        let hash_salt = this.project.next_config().output_hash_salt();
++
+         let mut server_output_assets = traced_modules_for_entries(
+             module_graph,
+             Modules::empty(),
+             self.entries(),
+             Some(self.ignores()),
+             None,
++            hash_salt,
+         )
+         .await?
+         .iter()
+@@ -133,7 +136,7 @@ impl Asset for ServerNftJsonAsset {
+                     .await?
+                     .context("NFT module has no content")?
+                     .content()
+-                    .hash(HashAlgorithm::Xxh3Hash128Hex)
++                    .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
+                     .await?,
+             ))
+         })
+@@ -150,7 +153,7 @@ impl Asset for ServerNftJsonAsset {
+                     .context("failed to compute relative path for server NFT JSON")?,
+                 module_path
+                     .read()
+-                    .hash(HashAlgorithm::Xxh3Hash128Hex)
++                    .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
+                     .await?,
+             ));
+ 
+@@ -170,7 +173,9 @@ impl Asset for ServerNftJsonAsset {
+                         base_dir
+                             .get_relative_path_to(file)
+                             .context("failed to compute relative path for server NFT JSON")?,
+-                        file.read().hash(HashAlgorithm::Xxh3Hash128Hex).await?,
++                        file.read()
++                            .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
++                            .await?,
+                     ))
+                 }
+             }
+diff --git a/crates/next-api/src/nft.rs b/crates/next-api/src/nft.rs
+index ef8162bd3984eb2e1d010ed904a8ee017d994399..f09e23c000afe2a8186b131dac85d677f66b925a 100644
+--- a/crates/next-api/src/nft.rs
++++ b/crates/next-api/src/nft.rs
+@@ -67,6 +67,7 @@ pub async fn trace_endpoint(
+     async {
+         let project_path = project.project_path().owned().await?;
+         let next_config = project.next_config();
++        let hash_salt = next_config.output_hash_salt();
+ 
+         let output_file_tracing_includes = next_config
+             .output_file_tracing_includes(project_path.clone())
+@@ -83,10 +84,11 @@ pub async fn trace_endpoint(
+                 .await?
+                 .map(|v| *v),
+             Some(next_config.config_file_path(project_path.clone())),
++            hash_salt,
+         )
+         .await?;
+ 
+-        let module_data = traced_module_data_for_graph(*module_graph, traced_entries)
++        let module_data = traced_module_data_for_graph(*module_graph, traced_entries, hash_salt)
+             .to_resolved()
+             .await?;
+         let module_paths = module_data.await?.idents;
+@@ -271,10 +273,11 @@ pub async fn traced_modules_for_entries(
+     traced_entries: Vc<Modules>,
+     exclude_glob: Option<Vc<Glob>>,
+     forbidden_path: Option<Vc<FileSystemPath>>,
++    hash_salt: Vc<RcStr>,
+ ) -> Result<Vc<Modules>> {
+     let exclude_glob_and_module_idents = if let Some(exclude_glob) = exclude_glob {
+         let exclude_glob = exclude_glob.await?;
+-        let data = traced_module_data_for_graph(module_graph, traced_entries).await?;
++        let data = traced_module_data_for_graph(module_graph, traced_entries, hash_salt).await?;
+         Some((exclude_glob, data.idents.await?))
+     } else {
+         None
+@@ -379,6 +382,7 @@ pub struct TracedModuleData {
+ pub async fn traced_module_data_for_graph(
+     module_graph: Vc<ModuleGraph>,
+     traced_entries: Vc<Modules>,
++    hash_salt: Vc<RcStr>,
+ ) -> Result<Vc<TracedModuleData>> {
+     // This function is very similar to traced_modules_for_entries, but doesn't apply the glob and
+     // is executed only once for the whole graph.
+@@ -420,7 +424,7 @@ pub async fn traced_module_data_for_graph(
+                         .await?
+                         .context("NFT module has no content")?
+                         .content()
+-                        .hash(HashAlgorithm::Xxh3Hash128Hex)
++                        .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
+                         .await?,
+                 ),
+             ))
+diff --git a/crates/next-api/src/nft_json.rs b/crates/next-api/src/nft_json.rs
+index 957b3c834621bf201f20a967e0774edfe3df0138..6d003c8adcf509a0549ee5db542a4311be7742fc 100644
+--- a/crates/next-api/src/nft_json.rs
++++ b/crates/next-api/src/nft_json.rs
+@@ -119,6 +119,7 @@ impl Asset for NftJsonAsset {
+             let output_root_ref = this.project.output_fs().root().await?;
+             let project_root_ref = this.project.project_fs().root().await?;
+             let next_config = this.project.next_config();
++            let hash_salt = next_config.output_hash_salt();
+ 
+             let client_root = this.project.client_fs().root();
+             let client_root = client_root.owned().await?;
+@@ -173,7 +174,11 @@ impl Asset for NftJsonAsset {
+                     let (referenced_chunk_path, hash) = match referenced {
+                         AssetOrModule::Asset(v) => (
+                             Either::Left(v.path().await?),
+-                            Either::Left(v.content().hash(HashAlgorithm::Xxh3Hash128Hex).await?),
++                            Either::Left(
++                                v.content()
++                                    .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
++                                    .await?,
++                            ),
+                         ),
+                         AssetOrModule::Module(v) => {
+                             let ident = module_data
+@@ -235,7 +240,10 @@ impl Asset for NftJsonAsset {
+                         Ok((
+                             relative_path,
+                             Either::Left(
+-                                file_path.read().hash(HashAlgorithm::Xxh3Hash128Hex).await?,
++                                file_path
++                                    .read()
++                                    .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
++                                    .await?,
+                             ),
+                         ))
+                     })
+@@ -266,7 +274,10 @@ impl Asset for NftJsonAsset {
+             // non-adapter consumers (which includes output:standalone) don't experience a breaking
+             // change, but instead we just add it as a separate field that only build-complete
+             // reads.
+-            let entry_hash = chunk.content().hash(HashAlgorithm::Xxh3Hash128Hex).await?;
++            let entry_hash = chunk
++                .content()
++                .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
++                .await?;
+             let json = json!({
+               "version": 1,
+               "files": files,
+diff --git a/crates/next-api/src/paths.rs b/crates/next-api/src/paths.rs
+index 3898419e8425863bb31e9895c915fc91ec21db08..b21dc5b98ea3f153e8120a7685a481799f5c793b 100644
+--- a/crates/next-api/src/paths.rs
++++ b/crates/next-api/src/paths.rs
+@@ -46,7 +46,7 @@ async fn asset_path(
+             } else {
+                 asset
+                     .content()
+-                    .hash(HashAlgorithm::Xxh3Hash128Hex)
++                    .hash(no_hash_salt(), HashAlgorithm::Xxh3Hash128Hex)
+                     .owned()
+                     .await?
+             };
+diff --git a/crates/next-api/src/routes_hashes_manifest.rs b/crates/next-api/src/routes_hashes_manifest.rs
+index 4fa51d728cc36039370e500053cfe505ff0a25e0..00cd2feaafeeaac8523673448fd147d32113c1f5 100644
+--- a/crates/next-api/src/routes_hashes_manifest.rs
++++ b/crates/next-api/src/routes_hashes_manifest.rs
+@@ -5,7 +5,7 @@ use turbo_tasks::{FxIndexMap, FxIndexSet, ResolvedVc, TryFlatJoinIterExt, TryJoi
+ use turbo_tasks_fs::{FileContent, FileSystemPath};
+ use turbo_tasks_hash::{DeterministicHash, HashAlgorithm, Xxh3Hash64Hasher, hash_xxh3_hash64};
+ use turbopack_core::{
+-    asset::{Asset, AssetContent},
++    asset::{Asset, AssetContent, no_hash_salt},
+     module::{Module, Modules},
+     module_graph::{GraphTraversalAction, ModuleGraph},
+     output::{
+@@ -62,7 +62,7 @@ pub async fn endpoints_outputs(endpoints: Vc<Endpoints>) -> Result<Vc<OutputAsse
+ }
+ 
+ #[turbo_tasks::function]
+-pub async fn outputs_hash(outputs: Vc<OutputAssets>) -> Result<Vc<u64>> {
++pub async fn outputs_hash(outputs: Vc<OutputAssets>, hash_salt: Vc<RcStr>) -> Result<Vc<u64>> {
+     let output_assets = expand_output_assets(
+         outputs
+             .await?
+@@ -73,7 +73,11 @@ pub async fn outputs_hash(outputs: Vc<OutputAssets>) -> Result<Vc<u64>> {
+     .await?;
+     let outputs_hashes = output_assets
+         .iter()
+-        .map(|asset| asset.content().hash(HashAlgorithm::Xxh3Hash128Hex))
++        .map(|asset| {
++            asset
++                .content()
++                .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
++        })
+         .try_join()
+         .await?;
+ 
+@@ -121,7 +125,11 @@ pub async fn endpoints_entry_modules(
+ }
+ 
+ #[turbo_tasks::function]
+-pub async fn sources_hash(module_graph: Vc<ModuleGraph>, modules: Vc<Modules>) -> Result<Vc<u64>> {
++pub async fn sources_hash(
++    module_graph: Vc<ModuleGraph>,
++    modules: Vc<Modules>,
++    hash_salt: Vc<RcStr>,
++) -> Result<Vc<u64>> {
+     let modules = modules.await?;
+ 
+     let mut all_modules = FxIndexSet::default();
+@@ -144,7 +152,11 @@ pub async fn sources_hash(module_graph: Vc<ModuleGraph>, modules: Vc<Modules>) -
+         .try_flat_join()
+         .await?
+         .into_iter()
+-        .map(|source| source.content().hash(HashAlgorithm::Xxh3Hash128Hex))
++        .map(|source| {
++            source
++                .content()
++                .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
++        })
+         .try_join()
+         .await?;
+ 
+@@ -181,6 +193,7 @@ impl RoutesHashesManifestAsset {
+ impl Asset for RoutesHashesManifestAsset {
+     #[turbo_tasks::function]
+     async fn content(&self) -> Result<Vc<AssetContent>> {
++        let hash_salt = no_hash_salt();
+         let module_graphs = self.project.whole_app_module_graphs().await?;
+         let base_module_graph = *module_graphs.base;
+         let full_module_graph = *module_graphs.full;
+@@ -195,8 +208,9 @@ impl Asset for RoutesHashesManifestAsset {
+                     sources_hash(
+                         full_module_graph,
+                         endpoint_entry_modules(base_module_graph, *entry.endpoint),
++                        hash_salt,
+                     ),
+-                    outputs_hash(endpoint_outputs(*entry.endpoint)),
++                    outputs_hash(endpoint_outputs(*entry.endpoint), hash_salt),
+                 )
+             } else {
+                 let endpoints = Vc::cell(primary.iter().map(|entry| entry.endpoint).collect());
+@@ -204,8 +218,9 @@ impl Asset for RoutesHashesManifestAsset {
+                     sources_hash(
+                         full_module_graph,
+                         endpoints_entry_modules(base_module_graph, endpoints),
++                        hash_salt,
+                     ),
+-                    outputs_hash(endpoints_outputs(endpoints)),
++                    outputs_hash(endpoints_outputs(endpoints), hash_salt),
+                 )
+             };
+             entrypoint_hashes.insert(key.as_str(), entry);
+diff --git a/crates/next-api/src/server_actions.rs b/crates/next-api/src/server_actions.rs
+index 050b35070e15c736eae4302a83b8d6411b89361d..7e666eefdfba1618c92bc4a95281e3b297b6a8b0 100644
+--- a/crates/next-api/src/server_actions.rs
++++ b/crates/next-api/src/server_actions.rs
+@@ -231,11 +231,11 @@ impl Asset for ServerActionManifestAsset {
+ 
+         let actions_value = self.actions.await?;
+         let async_module_info = self.module_graph.async_module_info();
+-        let durable_use_cache_entries = *self
+-            .project
+-            .next_config()
++        let next_config = self.project.next_config();
++        let durable_use_cache_entries = *next_config
+             .enable_durable_use_cache_entries(self.project.next_mode())
+             .await?;
++        let hash_salt = next_config.output_hash_salt();
+ 
+         let loader_id = self.chunk_item.id().await?;
+         let loader_id = match &loader_id {
+@@ -279,6 +279,7 @@ impl Asset for ServerActionManifestAsset {
+                                     *self.module_graph,
+                                     **module,
+                                     *self.chunking_context,
++                                    hash_salt,
+                                 )
+                                 .await?,
+                             )
+@@ -361,6 +362,7 @@ async fn compute_subtree_content_hash(
+     module_graph: ResolvedVc<ModuleGraph>,
+     entry: ResolvedVc<Box<dyn Module>>,
+     chunking_context: Vc<Box<dyn ChunkingContext>>,
++    hash_salt: Vc<RcStr>,
+ ) -> Result<Vc<RcStr>> {
+     let span = tracing::info_span!(
+         "compute use-cache code hash",
+@@ -408,8 +410,14 @@ async fn compute_subtree_content_hash(
+                     .map(async |m| Ok(format!(
+                         "  '{}': {}",
+                         m.ident_string().await?,
+-                        module_hash(*module_graph, chunking_context, async_module_info, **m)
+-                            .await?
++                        module_hash(
++                            *module_graph,
++                            chunking_context,
++                            async_module_info,
++                            **m,
++                            hash_salt
++                        )
++                        .await?
+                     )))
+                     .try_join()
+                     .await?
+@@ -419,7 +427,15 @@ async fn compute_subtree_content_hash(
+ 
+         let hashes = modules
+             .into_iter()
+-            .map(|m| module_hash(*module_graph, chunking_context, async_module_info, *m))
++            .map(|m| {
++                module_hash(
++                    *module_graph,
++                    chunking_context,
++                    async_module_info,
++                    *m,
++                    hash_salt,
++                )
++            })
+             .try_join()
+             .await?;
+ 
+@@ -448,6 +464,7 @@ async fn module_hash(
+     chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
+     async_module_info: ResolvedVc<AsyncModulesInfo>,
+     m: ResolvedVc<Box<dyn Module>>,
++    hash_salt: Vc<RcStr>,
+ ) -> Result<Vc<RcStr>> {
+     let ident = m.ident();
+     let ident_value = ident.await?;
+@@ -484,7 +501,7 @@ async fn module_hash(
+             .await?
+             .with_context(|| format!("failed to get source for module {ident_str}"))?
+             .content()
+-            .hash(HashAlgorithm::Xxh3Hash128Hex)
++            .hash(hash_salt, HashAlgorithm::Xxh3Hash128Hex)
+             .await?;
+         Ok(Vc::cell(RcStr::from(deterministic_hash(
+             "",
+diff --git a/packages/next/src/build/adapter/build-complete.ts b/packages/next/src/build/adapter/build-complete.ts
+index f38163fba9b2e14c170321155ee2300b071ea428..06b283db29ff09ffd8bec8e4d1fb3da6d7d03a89 100644
+--- a/packages/next/src/build/adapter/build-complete.ts
++++ b/packages/next/src/build/adapter/build-complete.ts
+@@ -1046,7 +1046,8 @@ export async function handleBuildComplete({
+               existingOutput.assetsHashes,
+               path.relative(repoRoot, pageFile),
+               pageFile,
+-              bundler
++              bundler,
++              config.experimental.outputHashSalt || ''
+             )
+             continue
+           }
+@@ -2170,6 +2171,7 @@ async function getSharedNodeAssets({
+   const pagesSharedNodeAssetsHashes: Record<string, string> = {}
+   const appPagesSharedNodeAssets: Record<string, string> = {}
+   const appPagesSharedNodeAssetsHashes: Record<string, string> = {}
++  const salt = config.experimental.outputHashSalt || ''
+ 
+   const moduleTypes = ['app-page', 'pages'] as const
+ 
+@@ -2201,7 +2203,8 @@ async function getSharedNodeAssets({
+           pagesSharedNodeAssetsHashes,
+           rootRelativeFilePath,
+           path.join(repoRoot, rootRelativeFilePath),
+-          bundler
++          bundler,
++          salt
+         )
+       } else {
+         await pushAsset(
+@@ -2209,7 +2212,8 @@ async function getSharedNodeAssets({
+           appPagesSharedNodeAssetsHashes,
+           rootRelativeFilePath,
+           path.join(repoRoot, rootRelativeFilePath),
+-          bundler
++          bundler,
++          salt
+         )
+       }
+     }
+@@ -2226,7 +2230,8 @@ async function getSharedNodeAssets({
+     sharedNodeAssetsHashes,
+     path.relative(repoRoot, setupNodeStubPath),
+     require.resolve('next/dist/build/adapter/setup-node-env.external'),
+-    bundler
++    bundler,
++    salt
+   )
+ 
+   // Turbopack handles this automatically and these files are listed in the nft.json files.
+@@ -2315,7 +2320,8 @@ async function getSharedNodeAssets({
+         sharedNodeAssetsHashes,
+         path.relative(repoRoot, absoluteFilePath),
+         absoluteFilePath,
+-        bundler
++        bundler,
++        salt
+       )
+     }
+   }
+@@ -2338,6 +2344,7 @@ async function getSharedNodeAssets({
+       fileOutputPath,
+       path.join(distDir, 'server', 'instrumentation.js'),
+       bundler,
++      salt,
+       instrumentationEntryHash
+     )
+   }
+@@ -2352,7 +2359,8 @@ async function getSharedNodeAssets({
+       sharedNodeAssetsHashes,
+       fileOutputPath,
+       filePath,
+-      bundler
++      bundler,
++      salt
+     )
+   }
+ 
+@@ -2372,13 +2380,14 @@ async function pushAsset(
+   targetFilePath: string,
+   sourceFilePath: string,
+   bundler: Bundler,
++  salt: string,
+   hashOverride?: string
+ ) {
+   if (!(targetFilePath in assets)) {
+     assets[targetFilePath] = sourceFilePath
+     if (bundler === Bundler.Turbopack) {
+       assetsHashes[targetFilePath] =
+-        hashOverride ?? (await hashFile(sourceFilePath))
++        hashOverride ?? (await hashFile(salt, sourceFilePath))
+     }
+   }
+ }
+@@ -2411,8 +2420,9 @@ async function loadNFT(
+   return { entryHash }
+ }
+ 
+-async function hashFile(filePath: string): Promise<string> {
++async function hashFile(salt: string, filePath: string): Promise<string> {
+   const hash = crypto.createHash('sha256')
++  hash.update(salt)
+   try {
+     // Try symlink first, since readFile just transparently resolves those (or fails if it's a
+     // directory symlink).
+diff --git a/turbopack/crates/turbo-tasks-fs/src/lib.rs b/turbopack/crates/turbo-tasks-fs/src/lib.rs
+index 5546fc1001e90e436b64a529388c67ec86457933..d99202da6518e2f28e852554fdcb881bb75a1912 100644
+--- a/turbopack/crates/turbo-tasks-fs/src/lib.rs
++++ b/turbopack/crates/turbo-tasks-fs/src/lib.rs
+@@ -2531,9 +2531,12 @@ impl FileContent {
+     }
+ 
+     #[turbo_tasks::function]
+-    pub fn hash(&self, algorithm: HashAlgorithm) -> Vc<RcStr> {
+-        // no_hash_salt
+-        Vc::cell(RcStr::from(deterministic_hash("", self, algorithm)))
++    pub async fn hash(&self, salt: Vc<RcStr>, algorithm: HashAlgorithm) -> Result<Vc<RcStr>> {
++        Ok(Vc::cell(RcStr::from(deterministic_hash(
++            &salt.await?,
++            self,
++            algorithm,
++        ))))
+     }
+ 
+     /// Converts this [`FileContent`] into a [`PersistedFileContent`] by cloning.
+diff --git a/turbopack/crates/turbopack-core/src/asset.rs b/turbopack/crates/turbopack-core/src/asset.rs
+index 65cf0e7ecb3f1721ed80cfc7b99a825220a6ab65..860dd6bf169a58a817467dea8dd8e9d0607751b3 100644
+--- a/turbopack/crates/turbopack-core/src/asset.rs
++++ b/turbopack/crates/turbopack-core/src/asset.rs
+@@ -131,14 +131,14 @@ impl AssetContent {
+     }
+ 
+     #[turbo_tasks::function]
+-    pub fn hash(&self, algorithm: HashAlgorithm) -> Vc<RcStr> {
+-        match self {
+-            AssetContent::File(content) => content.hash(algorithm),
++    pub async fn hash(&self, salt: Vc<RcStr>, algorithm: HashAlgorithm) -> Result<Vc<RcStr>> {
++        Ok(match self {
++            AssetContent::File(content) => content.hash(salt, algorithm),
+             AssetContent::Redirect { target, link_type } => Vc::cell(RcStr::from(
+                 // no_hash_salt
+-                deterministic_hash("", (target, link_type), algorithm),
++                deterministic_hash(&salt.await?, (target, link_type), algorithm),
+             )),
+-        }
++        })
+     }
+ 
+     /// Compared to [AssetContent::hash], this hashes only the bytes of the file content and

nextjs-95738-assets-hash-salt/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch

nextjs-95738-assets-hash-salt/tests/Dockerfile

@@ -0,0 +1,43 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | env RUSTUP_HOME=/usr/local/rustup CARGO_HOME=/usr/local/cargo sh -s -- -y --no-modify-path --profile minimal --default-toolchain 1.90.0
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && NEXT_SKIP_NATIVE_POSTINSTALL=1 pnpm install --frozen-lockfile && PATH="$HOME/.cargo/bin:$PATH" pnpm swc-build-native && pnpm build' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app

nextjs-95738-assets-hash-salt/tests/test.patch

@@ -0,0 +1,61 @@
+diff --git a/test/production/deterministic-build/adapter-content-hashes.test.ts b/test/production/deterministic-build/adapter-content-hashes.test.ts
+index ece2fe51b9893389cecc4b03b59a781c0a80f552..d14d53680c89ed9e23da1fb3eed1db5e2b9c72ec 100644
+--- a/test/production/deterministic-build/adapter-content-hashes.test.ts
++++ b/test/production/deterministic-build/adapter-content-hashes.test.ts
+@@ -61,6 +61,56 @@ import { FILES } from './files'
+         outputs.pagesApi.forEach(validateOutput)
+         outputs.appRoutes.forEach(validateOutput)
+       })
++
++      it('hashes respect NEXT_HASH_SALT', async () => {
++        const {
++          outputs: outputs1,
++        }: Parameters<NextAdapter['onBuildComplete']>[0] = await next.readJSON(
++          'build-complete.json'
++        )
++
++        await next.stop()
++        next.env.NEXT_HASH_SALT = 'something-else'
++        await next.build()
++
++        const {
++          outputs: outputs2,
++        }: Parameters<NextAdapter['onBuildComplete']>[0] = await next.readJSON(
++          'build-complete.json'
++        )
++
++        let functions1 = Object.fromEntries(
++          [
++            ...outputs1.pages,
++            ...outputs1.pagesApi,
++            ...outputs1.appPages,
++            ...outputs1.appRoutes,
++          ].map((output) => [output.pathname, output.assetsHashes])
++        )
++        let functions2 = Object.fromEntries(
++          [
++            ...outputs2.pages,
++            ...outputs2.pagesApi,
++            ...outputs2.appPages,
++            ...outputs2.appRoutes,
++          ].map((output) => [output.pathname, output.assetsHashes])
++        )
++
++        for (const pathname in functions1) {
++          const function1 = functions1[pathname]
++          const function2 = functions2[pathname]
++          for (const file in function1) {
++            const hash1 = function1[file]
++            const hash2 = function2[file]
++            expect(hash1).toBeString()
++            if (hash1 === hash2) {
++              throw new Error(
++                `Hash for ${pathname} file ${file} did not change with NEXT_HASH_SALT: ${hash1}`
++              )
++            }
++          }
++        }
++      })
+     })
+   }
+ )

nextjs-95738-assets-hash-salt/tests/test.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='test/production/deterministic-build/adapter-content-hashes.test.ts' --exclude='test/production/deterministic-build/adapter-content-hashes.test.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  git -C /app restore --source=HEAD --staged --worktree -- 'test/production/deterministic-build/adapter-content-hashes.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/production/deterministic-build/adapter-content-hashes.test.ts' >/dev/null 2>&1 || true
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/test/production/deterministic-build/adapter-content-hashes.test.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'PATH="$HOME/.cargo/bin:$PATH" pnpm swc-build-native && pnpm --filter next build && pnpm test-start-turbo '"'"'test/production/deterministic-build/adapter-content-hashes.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'PATH="$HOME/.cargo/bin:$PATH" pnpm swc-build-native && pnpm --filter next build && pnpm test-start-turbo '"'"'test/production/deterministic-build/adapter-content-hashes.test.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'PATH="$HOME/.cargo/bin:$PATH" pnpm swc-build-native && pnpm --filter next build && pnpm test-start-turbo '"'"'test/production/adapter-config/adapter-config-export.test.ts'"'"' '"'"'test/production/adapter-config-i18n/adapter-config-i18n.test.ts'"'"''; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0

nextjs-95799-async-route-init-errors/environment/Dockerfile

@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && pnpm install --frozen-lockfile && NEXT_TELEMETRY_DISABLED=1 pnpm build' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app

nextjs-95799-async-route-init-errors/solution/gold.patch

@@ -0,0 +1,52 @@
+diff --git a/packages/next/src/server/route-modules/app-route/module.ts b/packages/next/src/server/route-modules/app-route/module.ts
+index 3718f09b25..d8c4820dd4 100644
+--- a/packages/next/src/server/route-modules/app-route/module.ts
++++ b/packages/next/src/server/route-modules/app-route/module.ts
+@@ -235,6 +235,9 @@ export class AppRouteRouteModule extends RouteModule<
+   // Non-null while an async userland module (top-level await) is loading.
+   // ensureUserland() awaits this before the first request is handled.
+   private _pendingUserland: Promise<void> | null = null
++  // Init error from an async userland module, rethrown by ensureUserland().
++  private _initError: unknown = null
++  private _hasInitError = false
+   // Synchronous per-request userland getter for Turbopack dev mode.
+   // Called on every request to pick up server HMR updates.
+   private readonly _getUserland?: () => AppRouteUserlandModule
+@@ -252,7 +255,12 @@ export class AppRouteRouteModule extends RouteModule<
+         this._pendingUserland = result.then((mod) => {
+           this._userland = mod
+           this._pendingUserland = null
+-          this._initFromUserland()
++          try {
++            this._initFromUserland()
++          } catch (err) {
++            this._initError = err
++            this._hasInitError = true
++          }
+         })
+       } else {
+         this._userland = result
+@@ -275,6 +283,9 @@ export class AppRouteRouteModule extends RouteModule<
+     if (this._pendingUserland) {
+       await this._pendingUserland
+     }
++    if (this._hasInitError) {
++      throw this._initError
++    }
+   }
+ 
+   constructor({
+@@ -312,7 +323,12 @@ export class AppRouteRouteModule extends RouteModule<
+         this._pendingUserland = result.then((mod) => {
+           this._userland = mod
+           this._pendingUserland = null
+-          this._initFromUserland()
++          try {
++            this._initFromUserland()
++          } catch (err) {
++            this._initError = err
++            this._hasInitError = true
++          }
+         })
+       } else {
+         this._userland = result

nextjs-95799-async-route-init-errors/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch

nextjs-95799-async-route-init-errors/tests/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && pnpm install --frozen-lockfile && NEXT_TELEMETRY_DISABLED=1 pnpm build' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app

nextjs-95799-async-route-init-errors/tests/test.patch

@@ -0,0 +1,142 @@
+diff --git a/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/api/data/route.ts b/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/api/data/route.ts
+new file mode 100644
+index 00000000..b26a97fd
+--- /dev/null
++++ b/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/api/data/route.ts
+@@ -0,0 +1,6 @@
++// Top-level await makes this an async module.
++await Promise.resolve()
++
++export async function GET() {
++  return Response.json({ ok: true })
++}
+diff --git a/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/layout.tsx b/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/layout.tsx
+new file mode 100644
+index 00000000..888614de
+--- /dev/null
++++ b/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/layout.tsx
+@@ -0,0 +1,8 @@
++import { ReactNode } from 'react'
++export default function Root({ children }: { children: ReactNode }) {
++  return (
++    <html>
++      <body>{children}</body>
++    </html>
++  )
++}
+diff --git a/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/page.tsx b/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/page.tsx
+new file mode 100644
+index 00000000..ff7159d9
+--- /dev/null
++++ b/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/page.tsx
+@@ -0,0 +1,3 @@
++export default function Page() {
++  return <p>hello world</p>
++}
+diff --git a/test/production/app-dir/output-export-async-route-module/fixtures/invalid/next.config.js b/test/production/app-dir/output-export-async-route-module/fixtures/invalid/next.config.js
+new file mode 100644
+index 00000000..fecf9218
+--- /dev/null
++++ b/test/production/app-dir/output-export-async-route-module/fixtures/invalid/next.config.js
+@@ -0,0 +1,8 @@
++/**
++ * @type {import('next').NextConfig}
++ */
++const nextConfig = {
++  output: 'export',
++}
++
++module.exports = nextConfig
+diff --git a/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/api/data/route.ts b/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/api/data/route.ts
+new file mode 100644
+index 00000000..c60b6bb7
+--- /dev/null
++++ b/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/api/data/route.ts
+@@ -0,0 +1,8 @@
++// Top-level await makes this an async module.
++await Promise.resolve()
++
++export const dynamic = 'force-static'
++
++export async function GET() {
++  return Response.json({ ok: true })
++}
+diff --git a/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/layout.tsx b/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/layout.tsx
+new file mode 100644
+index 00000000..888614de
+--- /dev/null
++++ b/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/layout.tsx
+@@ -0,0 +1,8 @@
++import { ReactNode } from 'react'
++export default function Root({ children }: { children: ReactNode }) {
++  return (
++    <html>
++      <body>{children}</body>
++    </html>
++  )
++}
+diff --git a/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/page.tsx b/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/page.tsx
+new file mode 100644
+index 00000000..ff7159d9
+--- /dev/null
++++ b/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/page.tsx
+@@ -0,0 +1,3 @@
++export default function Page() {
++  return <p>hello world</p>
++}
+diff --git a/test/production/app-dir/output-export-async-route-module/fixtures/valid/next.config.js b/test/production/app-dir/output-export-async-route-module/fixtures/valid/next.config.js
+new file mode 100644
+index 00000000..fecf9218
+--- /dev/null
++++ b/test/production/app-dir/output-export-async-route-module/fixtures/valid/next.config.js
+@@ -0,0 +1,8 @@
++/**
++ * @type {import('next').NextConfig}
++ */
++const nextConfig = {
++  output: 'export',
++}
++
++module.exports = nextConfig
+diff --git a/test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts b/test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts
+new file mode 100644
+index 00000000..0c8ac29a
+--- /dev/null
++++ b/test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts
+@@ -0,0 +1,36 @@
++import { join } from 'path'
++import { nextTestSetup } from 'e2e-utils'
++
++describe('output-export-async-route-module', () => {
++  describe('invalid route', () => {
++    const { next } = nextTestSetup({
++      files: join(__dirname, 'fixtures', 'invalid'),
++      skipStart: true,
++    })
++
++    // The route module uses top-level await, so its `output: 'export'`
++    // validation runs after the module settles instead of throwing during
++    // require(). The resulting error must still fail the build.
++    it('fails the build when an async route module is not statically exportable', async () => {
++      const { exitCode, cliOutput } = await next.build()
++      expect(cliOutput).toContain(
++        'not configured on route "/api/data" with "output: export"'
++      )
++      expect(exitCode).toEqual(expect.any(Number))
++      expect(exitCode).not.toBe(0)
++    })
++  })
++
++  describe('valid route', () => {
++    const { next } = nextTestSetup({
++      files: join(__dirname, 'fixtures', 'valid'),
++      skipStart: true,
++    })
++
++    it('exports an async route module that is statically exportable', async () => {
++      const { exitCode } = await next.build()
++      expect(exitCode).toBe(0)
++      expect(await next.readFile('out/api/data')).toBe('{"ok":true}')
++    })
++  })
++})

nextjs-95799-async-route-init-errors/tests/test.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/api/data/route.ts' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/api/data/route.ts/*' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/layout.tsx' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/layout.tsx/*' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/page.tsx' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/page.tsx/*' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/invalid/next.config.js' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/invalid/next.config.js/*' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/valid/app/api/data/route.ts' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/valid/app/api/data/route.ts/*' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/valid/app/layout.tsx' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/valid/app/layout.tsx/*' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/valid/app/page.tsx' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/valid/app/page.tsx/*' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/valid/next.config.js' --exclude='test/production/app-dir/output-export-async-route-module/fixtures/valid/next.config.js/*' --exclude='test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts' --exclude='test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  git -C /app restore --source=HEAD --staged --worktree -- 'test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/api/data/route.ts' 'test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/layout.tsx' 'test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/page.tsx' 'test/production/app-dir/output-export-async-route-module/fixtures/invalid/next.config.js' 'test/production/app-dir/output-export-async-route-module/fixtures/valid/app/api/data/route.ts' 'test/production/app-dir/output-export-async-route-module/fixtures/valid/app/layout.tsx' 'test/production/app-dir/output-export-async-route-module/fixtures/valid/app/page.tsx' 'test/production/app-dir/output-export-async-route-module/fixtures/valid/next.config.js' 'test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/api/data/route.ts' 'test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/layout.tsx' 'test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/page.tsx' 'test/production/app-dir/output-export-async-route-module/fixtures/invalid/next.config.js' 'test/production/app-dir/output-export-async-route-module/fixtures/valid/app/api/data/route.ts' 'test/production/app-dir/output-export-async-route-module/fixtures/valid/app/layout.tsx' 'test/production/app-dir/output-export-async-route-module/fixtures/valid/app/page.tsx' 'test/production/app-dir/output-export-async-route-module/fixtures/valid/next.config.js' 'test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts' >/dev/null 2>&1 || true
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/api/data/route.ts' '/app/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/layout.tsx' '/app/test/production/app-dir/output-export-async-route-module/fixtures/invalid/app/page.tsx' '/app/test/production/app-dir/output-export-async-route-module/fixtures/invalid/next.config.js' '/app/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/api/data/route.ts' '/app/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/layout.tsx' '/app/test/production/app-dir/output-export-async-route-module/fixtures/valid/app/page.tsx' '/app/test/production/app-dir/output-export-async-route-module/fixtures/valid/next.config.js' '/app/test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'NEXT_TELEMETRY_DISABLED=1 pnpm --filter next build && pnpm test-start-webpack '"'"'test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'NEXT_TELEMETRY_DISABLED=1 pnpm --filter next build && pnpm test-start-webpack '"'"'test/production/app-dir/output-export-async-route-module/output-export-async-route-module.test.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'true'; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0

nextjs-95946-file-sourcemaps/environment/Dockerfile

@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && NEXT_SKIP_NATIVE_POSTINSTALL=0 pnpm install --frozen-lockfile && pnpm build && pnpm exec playwright install --with-deps chromium' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app

nextjs-95946-file-sourcemaps/solution/gold.patch

@@ -0,0 +1,196 @@
+diff --git a/packages/next/src/server/dev/hot-reloader-turbopack.ts b/packages/next/src/server/dev/hot-reloader-turbopack.ts
+index 0fb2cb77bb..6c76ac9af4 100644
+--- a/packages/next/src/server/dev/hot-reloader-turbopack.ts
++++ b/packages/next/src/server/dev/hot-reloader-turbopack.ts
+@@ -1,7 +1,9 @@
+ import type { Socket } from 'net'
+ import { mkdir, writeFile } from 'fs/promises'
++import { realpathSync } from 'fs'
+ import * as inspector from 'inspector'
+-import { join, extname, relative } from 'path'
++import { join, extname, relative, isAbsolute } from 'path'
++import { fileURLToPath, pathToFileURL } from 'url'
+ 
+ import ws from 'next/dist/compiled/ws'
+ 
+@@ -84,6 +86,7 @@ import type { ModernSourceMapPayload } from '../lib/source-maps'
+ import { isDeferredEntry } from '../../build/entries'
+ import { isMetadataRouteFile } from '../../lib/metadata/is-metadata-route'
+ import { setBundlerFindSourceMapImplementation } from '../patch-error-inspect'
++import { setBundlerFindSourceMapURLImplementation } from '../lib/source-maps'
+ import { getNextErrorFeedbackMiddleware } from '../../next-devtools/server/get-next-error-feedback-middleware'
+ import {
+   formatIssue,
+@@ -279,6 +282,47 @@ function getSourceMapFromTurbopack(
+   }
+ }
+ 
++function getSourceMapURLFromTurbopack(
++  distDir: string,
++  scriptNameOrSourceURL: string
++): string | null {
++  // React invokes this with the raw stack-frame filename, which arrives
++  // either as an absolute filesystem path or as a `file:` URL. Anything else
++  // (`file:` URLs with a query are eval'd server HMR modules carrying inline
++  // source maps, `webpack-internal://`, `node:internal/...`, `<anonymous>`,
++  // ...) is not something we have an emitted source map for.
++  let scriptPath = scriptNameOrSourceURL
++  if (scriptNameOrSourceURL.startsWith('file://')) {
++    if (scriptNameOrSourceURL.includes('?')) {
++      return null
++    }
++    try {
++      scriptPath = fileURLToPath(scriptNameOrSourceURL)
++    } catch {
++      return null
++    }
++  }
++  if (!isAbsolute(scriptPath)) {
++    return null
++  }
++
++  // Only chunks emitted into `distDir` have an on-disk source map to point at.
++  const relativePath = relative(distDir, scriptPath)
++  if (
++    relativePath.startsWith('..') ||
++    // On Windows an absolute path on a different drive is returned unchanged
++    // rather than as a `..`-prefixed relative path.
++    isAbsolute(relativePath)
++  ) {
++    return null
++  }
++
++  // The emitted source map lives next to its chunk with a `.map` suffix (see
++  // `SourceMapAsset::path`). Encode through `pathToFileURL` so any special
++  // characters in the path are escaped into a well-formed `file:` URL.
++  return pathToFileURL(scriptPath + '.map').href
++}
++
+ export async function createHotReloaderTurbopack(
+   opts: SetupOpts & { isSrcDir: boolean },
+   serverFields: ServerFields,
+@@ -410,6 +454,14 @@ export async function createHotReloaderTurbopack(
+     getSourceMapFromTurbopack.bind(null, project)
+   )
+ 
++  let canonicalDistDir = distDir
++  try {
++    canonicalDistDir = realpathSync(distDir)
++  } catch {}
++  setBundlerFindSourceMapURLImplementation(
++    getSourceMapURLFromTurbopack.bind(null, canonicalDistDir)
++  )
++
+   // Set up code frame renderer using native bindings
+   const { installCodeFrameSupport } =
+     require('../lib/install-code-frame') as typeof import('../lib/install-code-frame')
+@@ -417,6 +469,7 @@ export async function createHotReloaderTurbopack(
+ 
+   opts.onDevServerCleanup?.(async () => {
+     setBundlerFindSourceMapImplementation(() => undefined)
++    setBundlerFindSourceMapURLImplementation(() => null)
+     await project.onExit()
+     await lockfile?.unlock()
+   })
+diff --git a/packages/next/src/server/lib/source-maps.ts b/packages/next/src/server/lib/source-maps.ts
+index 40b3a2204c..10f8a4880b 100644
+--- a/packages/next/src/server/lib/source-maps.ts
++++ b/packages/next/src/server/lib/source-maps.ts
+@@ -158,6 +158,36 @@ export function filterStackFrameDEV(
+   }
+ }
+ 
++// `scriptNameOrSourceURL` is what React forwards from the stack frame: the
++// script's `getScriptNameOrSourceURL()`, which for the server chunks we can
++// map is an absolute filesystem path, not a URL. The returned value is the
++// source map's URL (`file:` or `data:`).
++type FindSourceMapURL = (scriptNameOrSourceURL: string) => string | null
++// Find the URL of a source map using the bundler's API.
++// Shared via `globalThis` because this module is compiled both into the server
++// runtime bundles (which call `findSourceMapURLDEV`) and into `next/dist/server`
++// (where the dev server registers the implementation), and each copy has its own
++// module state.
++const bundlerFindSourceMapURLSymbol = Symbol.for(
++  'next.server.bundlerFindSourceMapURL'
++)
++
++export function setBundlerFindSourceMapURLImplementation(
++  findSourceMapURLImplementation: FindSourceMapURL
++): void {
++  ;(globalThis as any)[bundlerFindSourceMapURLSymbol] =
++    findSourceMapURLImplementation
++}
++
++function bundlerFindSourceMapURL(scriptNameOrSourceURL: string): string | null {
++  const implementation: FindSourceMapURL | undefined = (globalThis as any)[
++    bundlerFindSourceMapURLSymbol
++  ]
++  return implementation === undefined
++    ? null
++    : implementation(scriptNameOrSourceURL)
++}
++
+ const invalidSourceMap = Symbol('invalid-source-map')
+ const sourceMapURLs = new LRUCache<string | typeof invalidSourceMap>(
+   512 * 1024 * 1024,
+@@ -172,6 +202,19 @@ const sourceMapURLs = new LRUCache<string | typeof invalidSourceMap>(
+ export function findSourceMapURLDEV(
+   scriptNameOrSourceURL: string
+ ): string | null {
++  try {
++    const bundlerSourceMapURL = bundlerFindSourceMapURL(scriptNameOrSourceURL)
++    if (bundlerSourceMapURL !== null) {
++      return bundlerSourceMapURL
++    }
++  } catch (cause) {
++    console.error(
++      `${scriptNameOrSourceURL}: Failed to find the source map URL. Cause: ${cause}`
++    )
++  }
++
++  // No bundler implementation (e.g. Webpack): inline the source map Node.js
++  // knows as a `data:` URL.
+   let sourceMapURL = sourceMapURLs.get(scriptNameOrSourceURL)
+   if (sourceMapURL === undefined) {
+     let sourceMapPayload: ModernSourceMapPayload | undefined
+diff --git a/packages/next/src/server/patch-error-inspect.ts b/packages/next/src/server/patch-error-inspect.ts
+index be16e4727b..2aa0025d1e 100644
+--- a/packages/next/src/server/patch-error-inspect.ts
++++ b/packages/next/src/server/patch-error-inspect.ts
+@@ -181,7 +181,10 @@ function getSourcemappedFrameIfPossible(
+   let sourceMapConsumer: SyncSourceMapConsumer
+   let sourceMapPayload: ModernSourceMapPayload
+   if (sourceMapCacheEntry === undefined) {
+-    let sourceURL = frame.file
++    // Fake frame scripts (`about://React/Server/file:///path/to/chunk.js?42`)
++    // have their positions padded to match the underlying chunk, so they
++    // resolve via the chunk's source map.
++    let sourceURL = devirtualizeReactServerURL(frame.file)
+     // e.g. "/Users/foo/APP/.next/server/chunks/ssr/[root-of-the-server]__2934a0._.js"
+     // or "C:\Users\foo\APP\.next\server\chunks\ssr\[root-of-the-server]__2934a0._.js"
+     // will be keyed by Node.js as "file:///APP/.next/server/chunks/ssr/[root-of-the-server]__2934a0._.js".
+@@ -189,8 +192,8 @@ function getSourcemappedFrameIfPossible(
+     //
+     // But frame.file might also be "webpack-internal:///(rsc)/./app/bad-sourcemap/page.js" or
+     // "<anonymous>" or "node:internal/process/task_queues" here
+-    if (path.isAbsolute(frame.file)) {
+-      sourceURL = url.pathToFileURL(frame.file).toString()
++    if (path.isAbsolute(sourceURL)) {
++      sourceURL = url.pathToFileURL(sourceURL).toString()
+     }
+     let maybeSourceMapPayload: ModernSourceMapPayload | undefined
+     try {
+@@ -228,10 +231,9 @@ function getSourcemappedFrameIfPossible(
+       // is sufficient to compute relative paths but is actually wrong (the
+       // chunk and sourcemap have different content hashes). We are using the
+       // node API to read the sourcemap and it doesn't give us access to the
+-      // URI. Devirtualize `about://React/Server/file:///path/to/chunk.js?4` to
+-      // `file:///path/to/chunk.js` so that relative `sources` in the source map
+-      // resolve against the real chunk URL, not the virtual one.
+-      const sourceMapURL = devirtualizeReactServerURL(sourceURL) + '.map'
++      // URI. `sourceURL` is already devirtualized so that relative `sources`
++      // resolve against the real chunk URL, not React's virtual one.
++      const sourceMapURL = sourceURL + '.map'
+       sourceMapConsumer = new SyncSourceMapConsumer(
+         sourceMapPayload,
+         // @ts-expect-error: our typings don't include this parameter but it is here.

nextjs-95946-file-sourcemaps/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch

nextjs-95946-file-sourcemaps/tests/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && NEXT_SKIP_NATIVE_POSTINSTALL=0 pnpm install --frozen-lockfile && pnpm build && pnpm exec playwright install --with-deps chromium' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app

nextjs-95946-file-sourcemaps/tests/test.patch

@@ -0,0 +1,115 @@
+diff --git a/test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts b/test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts
+index be03cedc70..f59cd54945 100644
+--- a/test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts
++++ b/test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts
+@@ -229,6 +229,21 @@ describe('app-dir - server source maps - fake frame source maps', () => {
+           }).toEqual({ url: script.url, hasSourceMap: true })
+         }
+ 
++        if (isTurbopack) {
++          // The resolver silently falls back to inlining `data:` URLs, so a
++          // defect in the `file:` URL derivation keeps all behavior-based
++          // assertions green. Only this assertion catches it.
++          for (const script of fakeScripts) {
++            expect({
++              url: script.url,
++              sourceMapURL: script.sourceMapURL,
++            }).toEqual({
++              url: script.url,
++              sourceMapURL: expect.stringMatching(/^file:/),
++            })
++          }
++        }
++
+         // Resolve each source map like a debugger frontend and map the
+         // padded `_()` call position of each fake function back to its
+         // original source, like clicking the frame in a debugger would.
+@@ -282,6 +297,88 @@ describe('app-dir - server source maps - fake frame source maps', () => {
+         session.close()
+       }
+     })
++
++    it('fake stack frames from nested Flight requests are resolvable by an attached debugger', async () => {
++      // Rendering this page produces fake frame scripts whose frame
++      // filenames are `file:` URLs rather than file paths.
++      await next.render('/rsc-error-throw-cached')
++
++      const target = await findServerInspectorTarget()
++      const session = await CDPSession.connect(target.webSocketDebuggerUrl)
++      try {
++        const evalScripts: {
++          scriptId: string
++          url: string
++          sourceMapURL: string
++        }[] = []
++        session.onEvent = (method, params) => {
++          if (method === 'Debugger.scriptParsed' && params.hasSourceURL) {
++            evalScripts.push({
++              scriptId: params.scriptId,
++              url: params.url,
++              sourceMapURL: params.sourceMapURL ?? '',
++            })
++          }
++        }
++        await session.send('Debugger.enable', { maxScriptsCacheSize: 1 })
++
++        await retry(async () => {
++          expect(
++            evalScripts.filter((script) =>
++              script.url.startsWith('about://React/Cache/')
++            ).length
++          ).toBeGreaterThan(0)
++        })
++
++        // React emits a fake frame script under `about://React/` with a
++        // source map, or, when no source map could be found for it, under
++        // the frame's raw filename without one.
++        const fakeScripts = evalScripts.filter(
++          (script) =>
++            script.url.startsWith('about://React/') ||
++            (script.url.startsWith('file:') && script.sourceMapURL === '')
++        )
++        const mappedSources = new Set<string>()
++        for (const script of fakeScripts) {
++          expect({
++            url: script.url,
++            hasSourceMap: script.sourceMapURL !== '',
++          }).toEqual({ url: script.url, hasSourceMap: true })
++
++          const { sourceMap, mapURL } = await resolveSourceMapLikeADebugger(
++            session,
++            script.url,
++            script.sourceMapURL
++          )
++          const { scriptSource } = await session.send(
++            'Debugger.getScriptSource',
++            { scriptId: script.scriptId }
++          )
++          const callIndex = scriptSource.indexOf('_()')
++          if (callIndex === -1) continue
++          const line = scriptSource.slice(0, callIndex).split('\n').length
++          const column =
++            callIndex - (scriptSource.lastIndexOf('\n', callIndex) + 1)
++
++          const consumer = new SourceMap(sourceMap)
++          const original = consumer.findEntry(line - 1, column)
++          if (original.originalSource !== undefined) {
++            mappedSources.add(
++              mapURL === null
++                ? original.originalSource
++                : new URL(original.originalSource, mapURL).href
++            )
++          }
++        }
++
++        const testDirURL = url.pathToFileURL(fs.realpathSync(next.testDir))
++        expect([...mappedSources]).toContain(
++          `${testDirURL.href}/app/rsc-error-throw-cached/page.js`
++        )
++      } finally {
++        session.close()
++      }
++    })
+   } else {
+     it('server chunk source maps are resolvable by an attached debugger', async () => {
+       await next.render('/rsc-error-log')

nextjs-95946-file-sourcemaps/tests/test.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts' --exclude='test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  git -C /app restore --source=HEAD --staged --worktree -- 'test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts' >/dev/null 2>&1 || true
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'pnpm build && pnpm test-dev-turbo '"'"'test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm build && pnpm test-dev-turbo '"'"'test/e2e/app-dir/server-source-maps/fake-frame-source-maps.test.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'pnpm build && pnpm test-dev-turbo '"'"'test/e2e/app-dir/server-source-maps/server-source-maps.test.ts'"'"' '"'"'test/e2e/app-dir/server-source-maps/server-source-maps-edge.test.ts'"'"''; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0

nextjs-95967-single-learn-more-links/environment/Dockerfile

@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && pnpm install --frozen-lockfile && pnpm build --filter=next' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app

nextjs-95967-single-learn-more-links/solution/gold.patch

@@ -0,0 +1,297 @@
+diff --git a/packages/next/src/next-devtools/dev-overlay/container/errors.tsx b/packages/next/src/next-devtools/dev-overlay/container/errors.tsx
+index 38294ad223..3fd4d073de 100644
+--- a/packages/next/src/next-devtools/dev-overlay/container/errors.tsx
++++ b/packages/next/src/next-devtools/dev-overlay/container/errors.tsx
+@@ -441,9 +441,9 @@ export function getBlockingRouteErrorDetails(
+   }
+ 
+   const isBlockingPageLoadError =
+-    message.includes('/blocking-prerender-runtime#') ||
+-    message.includes('/blocking-prerender-dynamic#') ||
+-    message.includes('/instant-shell-url-data#')
++    message.includes('/blocking-prerender-runtime') ||
++    message.includes('/blocking-prerender-dynamic') ||
++    message.includes('/instant-shell-url-data')
+   if (isBlockingPageLoadError) {
+     return {
+       type: 'blocking-route',
+diff --git a/packages/next/src/server/app-render/blocking-route-messages.ts b/packages/next/src/server/app-render/blocking-route-messages.ts
+index 7cc4164862..ea60a1fb0e 100644
+--- a/packages/next/src/server/app-render/blocking-route-messages.ts
++++ b/packages/next/src/server/app-render/blocking-route-messages.ts
+@@ -4,9 +4,8 @@ export function createRuntimeBodyError(route: string): Error {
+       `\`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` accessed outside of \`<Suspense>\` prevents the route from being prerendered, blocking the page load and leading to a slower user experience.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-runtime#wrap-in-or-move-into-suspense\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-runtime#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-runtime`
+   )
+ }
+ 
+@@ -16,11 +15,9 @@ export function createDynamicBodyError(route: string): Error {
+       `\`fetch(...)\` or \`connection()\` accessed outside of \`<Suspense>\` prevents the route from being prerendered, blocking the page load and leading to a slower user experience.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-dynamic#wrap-in-or-move-into-suspense\n` +
+       `  - [cache] Cache the data access with \`"use cache"\` (does not apply to \`connection()\`)\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-dynamic#cache-the-component-or-data\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-dynamic#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-dynamic`
+   )
+ }
+ 
+@@ -30,9 +27,8 @@ export function createRuntimeBodyErrorInNavigation(route: string): Error {
+       `\`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` accessed outside of \`<Suspense>\` prevents the route from being prerendered or the navigation from being instant, leading to a slower user experience.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-runtime#wrap-in-or-move-into-suspense\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-runtime#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-runtime`
+   )
+ }
+ 
+@@ -42,9 +38,8 @@ export function createLinkBodyErrorInNavigation(route: string): Error {
+       `\`params\` or \`searchParams\` accessed outside of \`<Suspense>\` may prevent the navigation from being instant, leading to a slower user experience.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` +
+-      `    https://nextjs.org/docs/messages/instant-shell-url-data#wrap-in-or-move-into-suspense\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/instant-shell-url-data#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/instant-shell-url-data`
+   )
+ }
+ 
+@@ -54,11 +49,9 @@ export function createDynamicBodyErrorInNavigation(route: string): Error {
+       `\`fetch(...)\` or \`connection()\` accessed outside of \`<Suspense>\` prevents the route from being prerendered or the navigation from being instant, leading to a slower user experience.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-dynamic#wrap-in-or-move-into-suspense\n` +
+       `  - [cache] Cache the data access with \`"use cache"\` (does not apply to \`connection()\`)\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-dynamic#cache-the-component-or-data\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-dynamic#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-dynamic`
+   )
+ }
+ 
+@@ -73,11 +66,9 @@ export function createDynamicOrRuntimeBodyError(route: string): Error {
+       `\`fetch(...)\`, \`cookies()\`, \`headers()\`, \`params\`, \`searchParams\`, or \`connection()\` accessed outside of \`<Suspense>\` prevents the route from being prerendered, blocking the page load and leading to a slower user experience.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-dynamic#wrap-in-or-move-into-suspense\n` +
+       `  - [cache] For uncached data (\`fetch\`, database calls): cache the access with \`"use cache"\` (does not apply to \`connection()\`)\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-dynamic#cache-the-component-or-data\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-dynamic#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-dynamic`
+   )
+ }
+ 
+@@ -87,9 +78,8 @@ export function createLinkMetadataError(route: string): Error {
+       `This route's metadata is blocked, but the rest of its content can be prefetched. \`params\` or \`searchParams\` accessed in \`generateMetadata()\` prevent it from being prefetched.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [static] Use a static metadata export instead of \`generateMetadata()\`\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime#use-static-metadata\n` +
+-      `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime#mark-the-route-as-dynamic`
++      `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime`
+   )
+ }
+ 
+@@ -99,9 +89,8 @@ export function createRuntimeMetadataError(route: string): Error {
+       `This route's metadata is blocked, but the rest of its content can be prerendered. \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` accessed in \`generateMetadata()\` cause it to run dynamically.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [static] Use a static metadata export instead of \`generateMetadata()\`\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime#use-static-metadata\n` +
+-      `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime#mark-the-route-as-dynamic`
++      `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime`
+   )
+ }
+ 
+@@ -111,9 +100,8 @@ export function createDynamicMetadataError(route: string): Error {
+       `This route's metadata is blocked, but the rest of its content can be prerendered. \`fetch(...)\` or \`connection()\` accessed in \`generateMetadata()\` cause it to run dynamically.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [cache] Cache the metadata with \`"use cache"\` in \`generateMetadata()\` (does not apply to \`connection()\`)\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic#cache-the-metadata\n` +
+-      `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic#mark-the-route-as-dynamic`
++      `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic`
+   )
+ }
+ 
+@@ -123,9 +111,8 @@ export function createLinkViewportError(route: string): Error {
+       `\`params\` or \`searchParams\` in \`generateViewport()\` prevents the page from being prerendered, leading to a slower user experience.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [static] Use a static viewport export instead of \`generateViewport()\`\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime#use-static-viewport\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime`
+   )
+ }
+ 
+@@ -135,9 +122,8 @@ export function createRuntimeViewportError(route: string): Error {
+       `\`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` in \`generateViewport()\` prevents the page from being prerendered, leading to a slower user experience.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [static] Use a static viewport export instead of \`generateViewport()\`\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime#use-static-viewport\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime`
+   )
+ }
+ 
+@@ -147,9 +133,8 @@ export function createDynamicViewportError(route: string): Error {
+       `\`fetch(...)\` or \`connection()\` in \`generateViewport()\` prevents the page from being prerendered, leading to a slower user experience.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [cache] Cache the viewport data with \`"use cache"\` in \`generateViewport()\` (does not apply to \`connection()\`)\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic#cache-the-viewport-data\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic`
+   )
+ }
+ 
+@@ -164,11 +149,9 @@ export function createDynamicOrRuntimeViewportError(route: string): Error {
+       `This prevents the page from being prerendered, leading to a slower user experience. Unlike metadata, viewport cannot be streamed behind \`<Suspense>\` because it affects the initial page load.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [static] Use a static viewport export instead of \`generateViewport()\`\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime#use-static-viewport\n` +
+       `  - [cache] For uncached data (\`fetch\`, database calls): cache the viewport with \`"use cache"\` in \`generateViewport()\` (does not apply to \`connection()\`)\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic#cache-the-viewport-data\n` +
+-      `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic#allow-blocking-route`
++      `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime`
+   )
+ }
+ 
+@@ -183,11 +166,9 @@ export function createDynamicOrRuntimeMetadataError(route: string): Error {
+       `This route's metadata is blocked, but the rest of its content can be prerendered.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [static] Use a static metadata export instead of \`generateMetadata()\`\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime#use-static-metadata\n` +
+       `  - [cache] Cache the metadata with \`"use cache"\` in \`generateMetadata()\` (does not apply to \`connection()\`)\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic#cache-the-metadata\n` +
+-      `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n` +
+-      `    https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic#mark-the-route-as-dynamic`
++      `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime`
+   )
+ }
+ 
+diff --git a/packages/next/src/server/app-render/sync-io-messages.ts b/packages/next/src/server/app-render/sync-io-messages.ts
+index d65037c58d..b41ef8e909 100644
+--- a/packages/next/src/server/app-render/sync-io-messages.ts
++++ b/packages/next/src/server/app-render/sync-io-messages.ts
+@@ -18,18 +18,12 @@ const SYNC_IO_RUNTIME_DOCS: Record<SyncIOApiType, string> = {
+   crypto: 'https://nextjs.org/docs/messages/blocking-prerender-crypto',
+ }
+ 
+-function elapsedTimeBullet(type: SyncIOApiType, docsUrl: string): string {
++function elapsedTimeBullet(type: SyncIOApiType): string {
+   return type === 'time'
+-    ? `\n  - [measure] If the value is for telemetry, use a timing API such as \`performance.now()\`\n    ${docsUrl}#for-telemetry-use-a-timing-api`
++    ? `\n  - [measure] If the value is for telemetry, use a timing API such as \`performance.now()\``
+     : ''
+ }
+ 
+-const CACHE_ANCHOR: Record<SyncIOApiType, string> = {
+-  random: '#cache-the-random-value',
+-  time: '#cache-the-timestamp',
+-  crypto: '#cache-the-generated-value',
+-}
+-
+ function createSyncIOErrorImpl(
+   route: string,
+   expression: string,
+@@ -40,10 +34,11 @@ function createSyncIOErrorImpl(
+     `Route "${route}": Next.js encountered the unstable value ${expression} while prerendering.\n\n` +
+       `This value can change between renders, so it must be either prerendered or computed later.\n\n` +
+       `Ways to fix this:\n` +
+-      `  - [dynamic] Render at request time by adding a dynamic data access (e.g. \`await connection()\`) before this call\n    ${docsUrl}#generate-on-every-request\n` +
+-      `  - [cache] Prerender and cache the value with \`"use cache"\`\n    ${docsUrl}${CACHE_ANCHOR[type]}\n` +
+-      `  - [client] Render the value on the client with \`"use client"\`\n    ${docsUrl}#render-on-the-client` +
+-      elapsedTimeBullet(type, docsUrl)
++      `  - [dynamic] Render at request time by adding a dynamic data access (e.g. \`await connection()\`) before this call\n` +
++      `  - [cache] Prerender and cache the value with \`"use cache"\`\n` +
++      `  - [client] Render the value on the client with \`"use client"\`` +
++      elapsedTimeBullet(type) +
++      `\n\nLearn more: ${docsUrl}`
+   )
+ }
+ 
+@@ -78,8 +73,9 @@ export function createSyncIOClientError(
+     `Route "${route}": Next.js encountered the unstable value ${expression} in a Client Component.\n\n` +
+       `This value would be evaluated during the prerender, instead of recomputed on each visit.\n\n` +
+       `Ways to fix this:\n` +
+-      `  - [stream] Wrap the Client Component in \`<Suspense fallback={...}>\`\n    ${docsUrl}#wrap-in-or-move-into-suspense\n` +
+-      `  - [defer] Move the read into a \`useEffect\` or event handler\n    ${docsUrl}#move-into-effect-or-event-handler` +
+-      elapsedTimeBullet(type, docsUrl)
++      `  - [stream] Wrap the Client Component in \`<Suspense fallback={...}>\`\n` +
++      `  - [defer] Move the read into a \`useEffect\` or event handler` +
++      elapsedTimeBullet(type) +
++      `\n\nLearn more: ${docsUrl}`
+   )
+ }
+diff --git a/packages/next/src/server/dynamic-rendering-utils.ts b/packages/next/src/server/dynamic-rendering-utils.ts
+index 4158512e7f..91dcb37339 100644
+--- a/packages/next/src/server/dynamic-rendering-utils.ts
++++ b/packages/next/src/server/dynamic-rendering-utils.ts
+@@ -42,9 +42,8 @@ export class ClientHookDynamicError extends Error {
+         `This blocks prerendering because the value is only available at runtime.\n\n` +
+         `Ways to fix this:\n` +
+         `  - [stream] Wrap the component in \`<Suspense fallback={...}>\` so the hook value streams in after prerendering\n` +
+-        `    https://nextjs.org/docs/messages/blocking-prerender-client-hook#wrap-in-or-move-into-suspense\n` +
+-        `  - [block] Set \`export const instant = false\` to allow a blocking route\n` +
+-        `    https://nextjs.org/docs/messages/blocking-prerender-client-hook#allow-blocking-route`
++        `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` +
++        `Learn more: https://nextjs.org/docs/messages/blocking-prerender-client-hook`
+     )
+   }
+ }
+diff --git a/packages/next/src/shared/lib/instant-messages.ts b/packages/next/src/shared/lib/instant-messages.ts
+index b53b6a41ac..ce620c8738 100644
+--- a/packages/next/src/shared/lib/instant-messages.ts
++++ b/packages/next/src/shared/lib/instant-messages.ts
+@@ -11,9 +11,8 @@ export function createUnrenderedSegmentError(
+       `\n\n${label}:\n${missingFiles.map((p) => `  ${p}`).join('\n')}` +
+       `\n\nWays to fix this:` +
+       `\n  - [render] Render the dropped segment` +
+-      `\n    https://nextjs.org/docs/messages/instant-unrendered-segment#render-the-dropped-segment` +
+       `\n  - [ignore] Set \`export const instant = false\` to opt the dropped segment out of instant-navigation validation` +
+-      `\n    https://nextjs.org/docs/messages/instant-unrendered-segment#skip-validation-on-the-segment`
++      `\n\nLearn more: https://nextjs.org/docs/messages/instant-unrendered-segment`
+   }
+   return new Error(message)
+ }
+@@ -24,10 +23,8 @@ export function createLinkPrefetchPartialError(pathname: string): Error {
+       `This will lead to slower, more expensive prefetches.\n\n` +
+       `Ways to fix this:\n` +
+       `  - [upgrade] Opt into Partial Prefetching by exporting \`const prefetch = 'partial'\` from the page or layout, or by setting \`partialPrefetching: true\` in next.config to opt the whole app in\n` +
+-      `    https://nextjs.org/docs/messages/instant-link-prefetch-partial#opt-into-partial-prefetching\n` +
+       `  - [disable] Remove \`prefetch={true}\` from the <Link> to use the default prefetch\n` +
+-      `    https://nextjs.org/docs/messages/instant-link-prefetch-partial#use-the-default-prefetch\n` +
+-      `  - [ignore] Set \`export const instant = false\` to opt the route out of instant-navigation validation\n` +
+-      `    https://nextjs.org/docs/messages/instant-link-prefetch-partial#disable-validation-on-this-route`
++      `  - [ignore] Set \`export const instant = false\` to opt the route out of instant-navigation validation\n\n` +
++      `Learn more: https://nextjs.org/docs/messages/instant-link-prefetch-partial`
+   )
+ }

nextjs-95967-single-learn-more-links/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch

nextjs-95967-single-learn-more-links/tests/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && pnpm install --frozen-lockfile && pnpm build --filter=next' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app

nextjs-95967-single-learn-more-links/tests/test.patch

@@ -0,0 +1,276 @@
+diff --git a/packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts b/packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts
+new file mode 100644
+index 00000000..5b889dba
+--- /dev/null
++++ b/packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts
+@@ -0,0 +1,270 @@
++import {
++  createDynamicBodyError,
++  createDynamicBodyErrorInNavigation,
++  createDynamicMetadataError,
++  createDynamicOrRuntimeBodyError,
++  createDynamicOrRuntimeMetadataError,
++  createDynamicOrRuntimeViewportError,
++  createDynamicViewportError,
++  createLinkBodyErrorInNavigation,
++  createLinkMetadataError,
++  createLinkViewportError,
++  createRuntimeBodyError,
++  createRuntimeBodyErrorInNavigation,
++  createRuntimeMetadataError,
++  createRuntimeViewportError,
++} from '../../../server/app-render/blocking-route-messages'
++import {
++  createSyncIOClientError,
++  createSyncIOError,
++  createSyncIORuntimeError,
++  type SyncIOApiType,
++} from '../../../server/app-render/sync-io-messages'
++import { ClientHookDynamicError } from '../../../server/dynamic-rendering-utils'
++import {
++  createLinkPrefetchPartialError,
++  createUnrenderedSegmentError,
++} from '../../../shared/lib/instant-messages'
++import { getCards } from '../components/instant/instant-guidance-data'
++import { getBlockingRouteErrorDetails } from './errors'
++
++const ROUTE = '/insight-test'
++
++type MessageCase = {
++  name: string
++  error: () => Error
++  docs: string | string[]
++  labels: string[]
++  context?: string[]
++}
++
++function expectSingleLearnMoreLink({
++  error,
++  docs,
++  labels,
++  context = [ROUTE],
++}: MessageCase): void {
++  const message = error().message
++  const urls = message.match(/https:\/\/[^\s]+/g) ?? []
++  const allowedDocs = Array.isArray(docs) ? docs : [docs]
++  const renderedLabels = Array.from(
++    message.matchAll(/^\s*-\s*\[([a-z]+)\]/gm),
++    (match) => match[1]
++  )
++  const learnMoreLines = Array.from(
++    message.matchAll(/^Learn more: (https:\/\/[^\s]+)$/gm),
++    (match) => match[1]
++  )
++
++  expect(renderedLabels).toEqual(labels)
++  expect(learnMoreLines).toHaveLength(1)
++  expect(allowedDocs).toContain(learnMoreLines[0])
++  expect(urls).toEqual(learnMoreLines)
++  expect(learnMoreLines[0]).not.toContain('#')
++  expect(message).toMatch(/\n\nLearn more: https:\/\/[^\s]+\n?$/)
++  for (const value of context) {
++    expect(message).toContain(value)
++  }
++}
++
++const blockingRouteCases: MessageCase[] = [
++  {
++    name: 'runtime body',
++    error: () => createRuntimeBodyError(ROUTE),
++    docs: 'https://nextjs.org/docs/messages/blocking-prerender-runtime',
++    labels: ['stream', 'block'],
++  },
++  {
++    name: 'dynamic body',
++    error: () => createDynamicBodyError(ROUTE),
++    docs: 'https://nextjs.org/docs/messages/blocking-prerender-dynamic',
++    labels: ['stream', 'cache', 'block'],
++  },
++  {
++    name: 'runtime body during navigation',
++    error: () => createRuntimeBodyErrorInNavigation(ROUTE),
++    docs: 'https://nextjs.org/docs/messages/blocking-prerender-runtime',
++    labels: ['stream', 'block'],
++  },
++  {
++    name: 'URL body during navigation',
++    error: () => createLinkBodyErrorInNavigation(ROUTE),
++    docs: 'https://nextjs.org/docs/messages/instant-shell-url-data',
++    labels: ['stream', 'block'],
++  },
++  {
++    name: 'dynamic body during navigation',
++    error: () => createDynamicBodyErrorInNavigation(ROUTE),
++    docs: 'https://nextjs.org/docs/messages/blocking-prerender-dynamic',
++    labels: ['stream', 'cache', 'block'],
++  },
++  {
++    name: 'combined dynamic and runtime body',
++    error: () => createDynamicOrRuntimeBodyError(ROUTE),
++    docs: 'https://nextjs.org/docs/messages/blocking-prerender-dynamic',
++    labels: ['stream', 'cache', 'block'],
++  },
++  {
++    name: 'URL metadata',
++    error: () => createLinkMetadataError(ROUTE),
++    docs:
++      'https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime',
++    labels: ['static', 'dynamic'],
++  },
++  {
++    name: 'runtime metadata',
++    error: () => createRuntimeMetadataError(ROUTE),
++    docs:
++      'https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime',
++    labels: ['static', 'dynamic'],
++  },
++  {
++    name: 'dynamic metadata',
++    error: () => createDynamicMetadataError(ROUTE),
++    docs:
++      'https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic',
++    labels: ['cache', 'dynamic'],
++  },
++  {
++    name: 'combined dynamic and runtime metadata',
++    error: () => createDynamicOrRuntimeMetadataError(ROUTE),
++    docs: [
++      'https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime',
++      'https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic',
++    ],
++    labels: ['static', 'cache', 'dynamic'],
++  },
++  {
++    name: 'URL viewport',
++    error: () => createLinkViewportError(ROUTE),
++    docs:
++      'https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime',
++    labels: ['static', 'block'],
++  },
++  {
++    name: 'runtime viewport',
++    error: () => createRuntimeViewportError(ROUTE),
++    docs:
++      'https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime',
++    labels: ['static', 'block'],
++  },
++  {
++    name: 'dynamic viewport',
++    error: () => createDynamicViewportError(ROUTE),
++    docs:
++      'https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic',
++    labels: ['cache', 'block'],
++  },
++  {
++    name: 'combined dynamic and runtime viewport',
++    error: () => createDynamicOrRuntimeViewportError(ROUTE),
++    docs: [
++      'https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime',
++      'https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic',
++    ],
++    labels: ['static', 'cache', 'block'],
++  },
++]
++
++const syncIoTypes: SyncIOApiType[] = ['time', 'random', 'crypto']
++const syncIoDocs: Record<SyncIOApiType, string> = {
++  time: 'https://nextjs.org/docs/messages/blocking-prerender-current-time',
++  random: 'https://nextjs.org/docs/messages/blocking-prerender-random',
++  crypto: 'https://nextjs.org/docs/messages/blocking-prerender-crypto',
++}
++
++const syncIoCases: MessageCase[] = syncIoTypes.flatMap((type) => {
++  const measure = type === 'time' ? ['measure'] : []
++  return [
++    {
++      name: `${type} prerender`,
++      error: () => createSyncIOError(ROUTE, `${type}()`, type),
++      docs: syncIoDocs[type],
++      labels: ['dynamic', 'cache', 'client', ...measure],
++      context: [ROUTE, `${type}()`],
++    },
++    {
++      name: `${type} runtime prerender`,
++      error: () => createSyncIORuntimeError(ROUTE, `${type}()`, type),
++      docs: syncIoDocs[type],
++      labels: ['dynamic', 'cache', 'client', ...measure],
++      context: [ROUTE, `${type}()`],
++    },
++    {
++      name: `${type} client component`,
++      error: () => createSyncIOClientError(ROUTE, `${type}()`, type),
++      docs: `${syncIoDocs[type]}-client`,
++      labels: ['stream', 'defer', ...measure],
++      context: [ROUTE, `${type}()`],
++    },
++  ]
++})
++
++const instantCases: MessageCase[] = [
++  {
++    name: 'client hook',
++    error: () => new ClientHookDynamicError(ROUTE, 'useSearchParams()'),
++    docs: 'https://nextjs.org/docs/messages/blocking-prerender-client-hook',
++    labels: ['stream', 'block'],
++    context: [ROUTE, 'useSearchParams()'],
++  },
++  {
++    name: 'unrendered segment',
++    error: () =>
++      createUnrenderedSegmentError(ROUTE, [
++        'app/@modal/default.tsx',
++        'app/@sidebar/default.tsx',
++      ]),
++    docs: 'https://nextjs.org/docs/messages/instant-unrendered-segment',
++    labels: ['render', 'ignore'],
++    context: [
++      ROUTE,
++      'app/@modal/default.tsx',
++      'app/@sidebar/default.tsx',
++    ],
++  },
++  {
++    name: 'partial link prefetch',
++    error: () => createLinkPrefetchPartialError(ROUTE),
++    docs: 'https://nextjs.org/docs/messages/instant-link-prefetch-partial',
++    labels: ['upgrade', 'disable', 'ignore'],
++  },
++]
++
++describe('insight console guidance', () => {
++  it.each([...blockingRouteCases, ...syncIoCases, ...instantCases])(
++    '$name has one anchor-less Learn more link after its labeled fixes',
++    expectSingleLearnMoreLink
++  )
++
++  it.each(blockingRouteCases)(
++    '$name remains recognizable by the development overlay',
++    ({ error }) => {
++      expect(getBlockingRouteErrorDetails(error())).not.toBeNull()
++    }
++  )
++
++  it('preserves the unrendered-segment input list', () => {
++    const message = createUnrenderedSegmentError(ROUTE, [
++      'app/@modal/default.tsx',
++      'app/@sidebar/default.tsx',
++    ]).message
++    expect(message).toContain('app/@modal/default.tsx')
++    expect(message).toContain('app/@sidebar/default.tsx')
++  })
++
++  it('keeps per-fix links on development-overlay cards', () => {
++    for (const [kind, variant] of [
++      ['blocking-route', 'dynamic'],
++      ['metadata', 'runtime'],
++      ['viewport', 'dynamic'],
++      ['link-prefetch-partial', 'runtime'],
++    ] as const) {
++      const cards = getCards(kind, variant)
++      expect(cards.length).toBeGreaterThan(1)
++      for (const card of cards) {
++        expect(card.link).toMatch(/^https:\/\/nextjs\.org\/docs\/messages\/[^#]+#.+/)
++      }
++    }
++  })
++})

nextjs-95967-single-learn-more-links/tests/test.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts' --exclude='packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  git -C /app restore --source=HEAD --staged --worktree -- 'packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts' >/dev/null 2>&1 || true
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'pnpm test-webpack '"'"'packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm test-webpack '"'"'packages/next/src/next-devtools/dev-overlay/container/insight-console-messages.test.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'pnpm test-webpack '"'"'packages/next/src/next-devtools/dev-overlay/container/errors.test.ts'"'"' '"'"'packages/next/src/shared/lib/deep-freeze.test.ts'"'"''; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0

nextjs-96022-dev-use-cache-invalidation/environment/Dockerfile

@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack install --global pnpm@10.33.0 && NEXT_SKIP_NATIVE_POSTINSTALL=0 pnpm install --frozen-lockfile && TURBO_TASKS_AVAILABLE_PARALLELISM=4 ANALYZE=1 pnpm build && pnpm exec playwright install --with-deps chromium && chmod -R a+rwX packages/next' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app

nextjs-96022-dev-use-cache-invalidation/solution/gold.patch

@@ -0,0 +1,547 @@
+diff --git a/packages/next/errors.json b/packages/next/errors.json
+index 94dd1aaade..7a88dde307 100644
+--- a/packages/next/errors.json
++++ b/packages/next/errors.json
+@@ -1445,5 +1445,6 @@
+   "1444": "Invalid target hostname \"%s\" for proxy request, expected \"%s\"",
+   "1445": "Invariant: Missing `__NEXT_PRIVATE_ORIGIN` environment variable.",
+   "1446": "Missing initURL",
+-  "1447": "Could not determine origin for forwarded Server Actions request. This can happen if port or hostname are not configured for this server."
++  "1447": "Could not determine origin for forwarded Server Actions request. This can happen if port or hostname are not configured for this server.",
++  "1448": "Error in the \"%s\" app-route HMR subscription"
+ }
+diff --git a/packages/next/src/build/templates/app-route.ts b/packages/next/src/build/templates/app-route.ts
+index e6e9d9b8a9..100ed82897 100644
+--- a/packages/next/src/build/templates/app-route.ts
++++ b/packages/next/src/build/templates/app-route.ts
+@@ -253,6 +253,7 @@ export async function handler(
+       validationLevel: nextConfig.experimental.instantInsights.validationLevel,
+       supportsDynamicResponse,
+       incrementalCache,
++      hmrRefreshHash: getRequestMeta(req, 'hmrRefreshHash'),
+       cacheLifeProfiles: nextConfig.cacheLife,
+       staticPageGenerationTimeout: nextConfig.staticPageGenerationTimeout,
+       waitUntil: ctx.waitUntil,
+diff --git a/packages/next/src/client/components/app-router-headers.ts b/packages/next/src/client/components/app-router-headers.ts
+index 30a8373be0..2d63005ae7 100644
+--- a/packages/next/src/client/components/app-router-headers.ts
++++ b/packages/next/src/client/components/app-router-headers.ts
+@@ -12,7 +12,6 @@ export const NEXT_ROUTER_PREFETCH_HEADER = 'next-router-prefetch' as const
+ export const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER =
+   'next-router-segment-prefetch' as const
+ export const NEXT_HMR_REFRESH_HEADER = 'next-hmr-refresh' as const
+-export const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__' as const
+ export const NEXT_URL = 'next-url' as const
+ export const RSC_CONTENT_TYPE_HEADER = 'text/x-component' as const
+ 
+diff --git a/packages/next/src/client/dev/hot-reloader/app/hot-reloader-app.tsx b/packages/next/src/client/dev/hot-reloader/app/hot-reloader-app.tsx
+index 35af5e073f..b3fbc56c4e 100644
+--- a/packages/next/src/client/dev/hot-reloader/app/hot-reloader-app.tsx
++++ b/packages/next/src/client/dev/hot-reloader/app/hot-reloader-app.tsx
+@@ -31,7 +31,6 @@ import type { McpPageMetadataResponse } from '../../../../shared/lib/mcp-page-me
+ import { useUntrackedPathname } from '../../../components/navigation-untracked'
+ import reportHmrLatency from '../../report-hmr-latency'
+ import { TurbopackHmr } from '../turbopack-hot-reloader-common'
+-import { NEXT_HMR_REFRESH_HASH_COOKIE } from '../../../components/app-router-headers'
+ import {
+   publicAppRouterInstance,
+   type GlobalErrorState,
+@@ -412,14 +411,9 @@ export function processMessage(
+         JSON.stringify({
+           event: 'server-component-reload-page',
+           clientId: __nextDevClientId,
+-          hash: message.hash,
+         })
+       )
+ 
+-      // Store the latest hash in a session cookie so that it's sent back to the
+-      // server with any subsequent requests.
+-      document.cookie = `${NEXT_HMR_REFRESH_HASH_COOKIE}=${message.hash};path=/`
+-
+       if (
+         RuntimeErrorHandler.hadRuntimeError ||
+         document.documentElement.id === '__next_error__'
+diff --git a/packages/next/src/server/app-render/app-render.tsx b/packages/next/src/server/app-render/app-render.tsx
+index 40c63d577a..40794f3be6 100644
+--- a/packages/next/src/server/app-render/app-render.tsx
++++ b/packages/next/src/server/app-render/app-render.tsx
+@@ -2856,6 +2856,7 @@ async function renderToHTMLOrFlightImpl(
+ 
+     const rootParams = getRootParams(loaderTree, ctx.getDynamicParamFromSegment)
+     const fallbackParams = getRequestMeta(req, 'fallbackParams') || null
++    const hmrRefreshHash = getRequestMeta(req, 'hmrRefreshHash')
+ 
+     const createRequestStore = createRequestStoreForRender.bind(
+       null,
+@@ -2869,7 +2870,8 @@ async function renderToHTMLOrFlightImpl(
+       isHmrRefresh,
+       serverComponentsHmrCache,
+       renderResumeDataCache,
+-      fallbackParams
++      fallbackParams,
++      hmrRefreshHash
+     )
+     const requestStore = createRequestStore()
+ 
+diff --git a/packages/next/src/server/app-render/work-unit-async-storage.external.ts b/packages/next/src/server/app-render/work-unit-async-storage.external.ts
+index 639426d5cb..f1cd69f1f6 100644
+--- a/packages/next/src/server/app-render/work-unit-async-storage.external.ts
++++ b/packages/next/src/server/app-render/work-unit-async-storage.external.ts
+@@ -18,7 +18,6 @@ import type {
+ import type { Params } from '../request/params'
+ import type { ImplicitTags } from '../lib/implicit-tags'
+ import type { WorkStore } from './work-async-storage.external'
+-import { NEXT_HMR_REFRESH_HASH_COOKIE } from '../../client/components/app-router-headers'
+ import { InvariantError } from '../../shared/lib/invariant-error'
+ import type { StagedRenderingController } from './staged-rendering'
+ import type { ValidationBoundaryTracking } from './instant-validation/boundary-tracking'
+@@ -61,6 +60,7 @@ export interface RequestStore extends CommonWorkUnitStore {
+   readonly draftMode: DraftModeProvider
+   readonly isHmrRefresh?: boolean
+   readonly serverComponentsHmrCache?: ServerComponentsHmrCache
++  readonly hmrRefreshHash?: string
+ 
+   readonly rootParams: Params
+ 
+@@ -438,9 +438,8 @@ export function getHmrRefreshHash(
+       case 'private-cache':
+       case 'prerender':
+       case 'prerender-runtime':
+-        return workUnitStore.hmrRefreshHash
+       case 'request':
+-        return workUnitStore.cookies.get(NEXT_HMR_REFRESH_HASH_COOKIE)?.value
++        return workUnitStore.hmrRefreshHash
+       case 'prerender-client':
+       case 'validation-client':
+       case 'prerender-ppr':
+diff --git a/packages/next/src/server/async-storage/request-store.ts b/packages/next/src/server/async-storage/request-store.ts
+index 9a9d2dde4d..c8ab6d82ae 100644
+--- a/packages/next/src/server/async-storage/request-store.ts
++++ b/packages/next/src/server/async-storage/request-store.ts
+@@ -126,6 +126,12 @@ export type RequestStoreInputs = {
+   previewProps: WrapperRenderOpts['previewProps']
+   isHmrRefresh: boolean | undefined
+   serverComponentsHmrCache: ServerComponentsHmrCache | undefined
++  /**
++   * The hash of the most recent server component change (dev only). Included in
++   * `"use cache"` cache keys so that cached entries are revalidated after an
++   * edit, for every client, regardless of whether it runs the HMR client.
++   */
++  hmrRefreshHash: string | undefined
+   fallbackParams: OpaqueFallbackRouteParams | null | undefined
+ }
+ 
+@@ -173,7 +179,8 @@ export function createRequestStoreForRender(
+   isHmrRefresh: RequestContext['isHmrRefresh'],
+   serverComponentsHmrCache: RequestContext['serverComponentsHmrCache'],
+   resumeDataCache: ResumeDataCache | null,
+-  fallbackParams: OpaqueFallbackRouteParams | null
++  fallbackParams: OpaqueFallbackRouteParams | null,
++  hmrRefreshHash: string | undefined
+ ): RequestStore {
+   return createRequestStore({
+     // Pages start in render phase by default
+@@ -193,6 +200,7 @@ export function createRequestStoreForRender(
+     previewProps,
+     isHmrRefresh,
+     serverComponentsHmrCache,
++    hmrRefreshHash,
+     fallbackParams,
+   })
+ }
+@@ -202,7 +210,8 @@ export function createRequestStoreForAPI(
+   url: RequestContext['url'],
+   implicitTags: RequestContext['implicitTags'],
+   onUpdateCookies: RenderOpts['onUpdateCookies'],
+-  previewProps: WrapperRenderOpts['previewProps']
++  previewProps: WrapperRenderOpts['previewProps'],
++  hmrRefreshHash: string | undefined
+ ): RequestStore {
+   return createRequestStore({
+     // API routes start in action phase by default
+@@ -216,6 +225,7 @@ export function createRequestStoreForAPI(
+     previewProps,
+     isHmrRefresh: false,
+     serverComponentsHmrCache: undefined,
++    hmrRefreshHash,
+     fallbackParams: null,
+   })
+ }
+@@ -239,6 +249,7 @@ export function createRequestStore(inputs: RequestStoreInputs): RequestStore {
+     previewProps,
+     isHmrRefresh,
+     serverComponentsHmrCache,
++    hmrRefreshHash,
+     fallbackParams,
+   } = inputs
+ 
+@@ -321,6 +332,7 @@ export function createRequestStore(inputs: RequestStoreInputs): RequestStore {
+     serverComponentsHmrCache:
+       serverComponentsHmrCache ||
+       (globalThis as any).__serverComponentsHmrCache,
++    hmrRefreshHash,
+     fallbackParams,
+   }
+ }
+diff --git a/packages/next/src/server/async-storage/work-store.ts b/packages/next/src/server/async-storage/work-store.ts
+index 6b8f4042b5..c765f13a23 100644
+--- a/packages/next/src/server/async-storage/work-store.ts
++++ b/packages/next/src/server/async-storage/work-store.ts
+@@ -28,6 +28,12 @@ export type WorkStoreContext = {
+     cacheLifeProfiles: ResolvedCacheLifeProfiles
+     staticPageGenerationTimeout: number
+     incrementalCache?: IncrementalCache
++    /**
++     * The hash of the most recent server component change (dev only). Included
++     * in `"use cache"` cache keys so that cached entries are revalidated after
++     * an edit, for every client, regardless of whether it runs the HMR client.
++     */
++    hmrRefreshHash?: string
+     isOnDemandRevalidate?: boolean
+     cacheComponents: boolean
+     validationLevel: ValidationLevel
+diff --git a/packages/next/src/server/base-server.ts b/packages/next/src/server/base-server.ts
+index d201b7151a..9ac5cbceb8 100644
+--- a/packages/next/src/server/base-server.ts
++++ b/packages/next/src/server/base-server.ts
+@@ -422,6 +422,15 @@ export default abstract class Server<
+       : undefined
+   }
+ 
++  /**
++   * The hash of the most recent server component change (dev only), used to
++   * revalidate `"use cache"` entries after an edit. Overridden by the dev
++   * server; returns `undefined` otherwise.
++   */
++  protected getServerComponentsHmrRefreshHash(): string | undefined {
++    return undefined
++  }
++
+   protected abstract loadEnvConfig(params: {
+     dev: boolean
+     forceReload: boolean
+@@ -1547,6 +1556,20 @@ export default abstract class Server<
+         )
+       }
+ 
++      // Attach the server components HMR refresh hash here, alongside the HMR
++      // cache, so it reaches every render that passes through this request
++      // handling, including internal renders (e.g. dev validation/warmup) that
++      // don't re-enter the top-level request handler. It's included in `"use
++      // cache"` keys so cached entries revalidate after an edit, for every
++      // client.
++      if (!getRequestMeta(req, 'hmrRefreshHash')) {
++        addRequestMeta(
++          req,
++          'hmrRefreshHash',
++          this.getServerComponentsHmrRefreshHash()
++        )
++      }
++
+       // when invokePath is specified we can short short circuit resolving
+       // we only honor this header if we are inside of a render worker to
+       // prevent external users coercing the routing path
+diff --git a/packages/next/src/server/dev/hot-reloader-turbopack.ts b/packages/next/src/server/dev/hot-reloader-turbopack.ts
+index 672abba0b6..3372f40d92 100644
+--- a/packages/next/src/server/dev/hot-reloader-turbopack.ts
++++ b/packages/next/src/server/dev/hot-reloader-turbopack.ts
+@@ -696,6 +696,14 @@ export async function createHotReloaderTurbopack(
+   let serverHmrSubscriptions: ServerHmrSubscriptions | undefined
+ 
+   let hmrEventHappened = false
++  // A counter identifying the current version of the compiled output, included
++  // by `"use cache"` in dev cache keys so that cached entries revalidate after
++  // an edit. It advances once per HMR change event (for App Router pages that
++  // is an RSC change, which is what a cached render depends on), independent of
++  // how many clients are connected. It deliberately does not advance on `BUILT`
++  // messages: those are sent per connected client on every compilation, so
++  // advancing there would both churn the hash without an edit and fail to
++  // advance it at all when no client is connected.
+   let hmrHash = 0
+ 
+   const clientsWithoutHtmlRequestId = new Set<ws>()
+@@ -1495,6 +1503,16 @@ export async function createHotReloaderTurbopack(
+       }
+     },
+ 
++    getServerComponentsHmrRefreshHash() {
++      // The current server-components generation. Only the change subscription
++      // (an actual recompile) advances `hmrHash`; reloads and config
++      // invalidations don't, so the value stays stable across requests until a
++      // real edit. Returned unconditionally (`"0"` before the first edit) so
++      // `"use cache"` keys are present and consistent for every request,
++      // mirroring webpack's always-present `stats.hash`.
++      return String(hmrHash)
++    },
++
+     sendToLegacyClients(action) {
+       const payload = JSON.stringify(action)
+ 
+@@ -1641,7 +1659,6 @@ export async function createHotReloaderTurbopack(
+         await clearAllModuleContexts()
+         this.send({
+           type: HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES,
+-          hash: String(++hmrHash),
+         })
+       }
+     },
+@@ -1922,7 +1939,10 @@ export async function createHotReloaderTurbopack(
+ 
+             sendToClient(client, {
+               type: HMR_MESSAGE_SENT_TO_BROWSER.BUILT,
+-              hash: String(++hmrHash),
++              // Report the current version without advancing it: a completed
++              // compilation is not itself an edit, and this hash is not
++              // consumed by the Turbopack client.
++              hash: String(hmrHash),
+               errors: [...clientErrors.values()],
+               warnings: [],
+             })
+@@ -1981,7 +2001,6 @@ export async function createHotReloaderTurbopack(
+         // Tell browsers to refetch RSC (soft refresh, not full page reload)
+         hotReloader.send({
+           type: HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES,
+-          hash: String(++hmrHash),
+         })
+       },
+     })
+diff --git a/packages/next/src/server/dev/hot-reloader-types.ts b/packages/next/src/server/dev/hot-reloader-types.ts
+index 04334c6f49..2e2855605d 100644
+--- a/packages/next/src/server/dev/hot-reloader-types.ts
++++ b/packages/next/src/server/dev/hot-reloader-types.ts
+@@ -117,7 +117,6 @@ export interface ReloadPageMessage {
+ 
+ export interface ServerComponentChangesMessage {
+   type: HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES
+-  hash: string
+ }
+ 
+ /**
+@@ -259,6 +258,13 @@ export interface NextJsHotReloaderInterface {
+    * and App Router clients that don't have Cache Components enabled.
+    */
+   sendToLegacyClients(action: HmrMessageSentToBrowser): void
++  /**
++   * The hash of the most recent server component change, or `undefined` if no
++   * server component change has occurred yet. In dev, this is included in `"use
++   * cache"` cache keys so that cached entries are revalidated after an edit,
++   * for every client, regardless of whether it runs the HMR client.
++   */
++  getServerComponentsHmrRefreshHash(): string | undefined
+   setCacheStatus(status: ServerCacheStatus, htmlRequestId: string): void
+   setReactDebugChannel(
+     debugChannel: ReactDebugChannelForBrowser,
+diff --git a/packages/next/src/server/dev/hot-reloader-webpack.ts b/packages/next/src/server/dev/hot-reloader-webpack.ts
+index 063ebe195a..3f687776c7 100644
+--- a/packages/next/src/server/dev/hot-reloader-webpack.ts
++++ b/packages/next/src/server/dev/hot-reloader-webpack.ts
+@@ -241,6 +241,7 @@ export default class HotReloaderWebpack implements NextJsHotReloaderInterface {
+   private serverError: Error | null = null
+   private hmrServerError: Error | null = null
+   private serverPrevDocumentHash: string | null
++  private serverComponentsHmrRefreshHash: string | undefined
+   private serverChunkNames?: Set<string>
+   private prevChunkNames?: Set<any>
+   private onDemandEntries?: ReturnType<typeof onDemandEntryHandler>
+@@ -431,14 +432,18 @@ export default class HotReloaderWebpack implements NextJsHotReloaderInterface {
+   }
+ 
+   protected async refreshServerComponents(hash: string): Promise<void> {
++    this.serverComponentsHmrRefreshHash = hash
+     this.send({
+       type: HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES,
+-      hash,
+       // TODO: granular reloading of changes
+       // entrypoints: serverComponentChanges,
+     })
+   }
+ 
++  public getServerComponentsHmrRefreshHash(): string | undefined {
++    return this.serverComponentsHmrRefreshHash
++  }
++
+   public onHMR(
+     req: IncomingMessage,
+     _socket: Duplex,
+diff --git a/packages/next/src/server/dev/next-dev-server.ts b/packages/next/src/server/dev/next-dev-server.ts
+index 5f40da7ef9..54fa3aaf96 100644
+--- a/packages/next/src/server/dev/next-dev-server.ts
++++ b/packages/next/src/server/dev/next-dev-server.ts
+@@ -231,6 +231,10 @@ export default class DevServer extends Server {
+     return this.serverComponentsHmrCache
+   }
+ 
++  protected override getServerComponentsHmrRefreshHash(): string | undefined {
++    return this.bundlerService.getServerComponentsHmrRefreshHash()
++  }
++
+   protected getRouteMatchers(): RouteMatcherManager {
+     const { pagesDir, appDir } = findPagesDir(this.dir)
+ 
+diff --git a/packages/next/src/server/dev/turbopack-utils.ts b/packages/next/src/server/dev/turbopack-utils.ts
+index 25155df83f..7aa2900da5 100644
+--- a/packages/next/src/server/dev/turbopack-utils.ts
++++ b/packages/next/src/server/dev/turbopack-utils.ts
+@@ -408,6 +408,34 @@ export async function handleRouteType({
+       const writtenEndpoint = await route.endpoint.writeToDisk()
+       hooks?.handleWrittenEndpoint(key, writtenEndpoint, false)
+ 
++      if (dev) {
++        // Advance the hot-reloader's HMR refresh hash whenever this route
++        // handler is recompiled, so its `"use cache"` entries are invalidated
++        // after an edit. Subscribing runs `subscribeToClientChanges`, which
++        // bumps the `hmrHash` counter on each change; that counter is returned
++        // by `getServerComponentsHmrRefreshHash` and folded into cache keys by
++        // `getHmrRefreshHash`. Unlike app pages there is no RSC for a connected
++        // browser to refetch, so `createMessage` returns nothing; the
++        // subscription exists only to advance the hash.
++        hooks?.subscribeToChanges(
++          key,
++          /** includeIssues= */ true,
++          route.endpoint,
++          () => undefined,
++          (error) => {
++            // This subscription only advances the refresh hash, so there is
++            // nothing to send the browser when it fails. `subscribeToChanges`
++            // drops the subscription on error and re-creates it the next time
++            // this route is ensured, so just log it.
++            console.error(
++              new Error(`Error in the "${page}" app-route HMR subscription`, {
++                cause: error,
++              })
++            )
++          }
++        )
++      }
++
+       const type = writtenEndpoint.type
+ 
+       manifestLoader.loadAppPathsManifest(page)
+diff --git a/packages/next/src/server/dev/use-cache-probe-worker.ts b/packages/next/src/server/dev/use-cache-probe-worker.ts
+index c77c7c8901..a29a26bcb4 100644
+--- a/packages/next/src/server/dev/use-cache-probe-worker.ts
++++ b/packages/next/src/server/dev/use-cache-probe-worker.ts
+@@ -167,6 +167,7 @@ export async function probeUseCache(msg: ProbeMessage): Promise<boolean> {
+       previewProps: undefined,
+       isHmrRefresh: msg.request.isHmrRefresh,
+       serverComponentsHmrCache: undefined,
++      hmrRefreshHash: msg.request.hmrRefreshHash,
+       fallbackParams: null,
+     })
+ 
+diff --git a/packages/next/src/server/lib/dev-bundler-service.ts b/packages/next/src/server/lib/dev-bundler-service.ts
+index c1e963d0f6..f284e79b12 100644
+--- a/packages/next/src/server/lib/dev-bundler-service.ts
++++ b/packages/next/src/server/lib/dev-bundler-service.ts
+@@ -64,6 +64,10 @@ export class DevBundlerService {
+     return await this.bundler.hotReloader.ensurePage(definition)
+   }
+ 
++  public getServerComponentsHmrRefreshHash(): string | undefined {
++    return this.bundler.hotReloader.getServerComponentsHmrRefreshHash()
++  }
++
+   public logErrorWithOriginalStack =
+     this.bundler.logErrorWithOriginalStack.bind(this.bundler)
+ 
+diff --git a/packages/next/src/server/request-meta.ts b/packages/next/src/server/request-meta.ts
+index db02b9abdd..0521765ea2 100644
+--- a/packages/next/src/server/request-meta.ts
++++ b/packages/next/src/server/request-meta.ts
+@@ -114,6 +114,14 @@ export interface RequestMeta {
+    */
+   serverComponentsHmrCache?: ServerComponentsHmrCache
+ 
++  /**
++   * The hash of the most recent server component change (dev only), set by the
++   * router-server from the hot-reloader. Included in `"use cache"` cache keys
++   * so that cached entries are revalidated after an edit, for every client,
++   * regardless of whether it runs the HMR client.
++   */
++  hmrRefreshHash?: string
++
+   /**
+    * Equals the segment path that was used for the prefetch RSC request.
+    */
+diff --git a/packages/next/src/server/route-modules/app-route/module.ts b/packages/next/src/server/route-modules/app-route/module.ts
+index d87306003e..5bcc998eac 100644
+--- a/packages/next/src/server/route-modules/app-route/module.ts
++++ b/packages/next/src/server/route-modules/app-route/module.ts
+@@ -805,7 +805,8 @@ export class AppRouteRouteModule extends RouteModule<
+       req.nextUrl,
+       implicitTags,
+       undefined,
+-      context.previewProps
++      context.previewProps,
++      context.renderOpts.hmrRefreshHash
+     )
+ 
+     const workStore = createWorkStore(staticGenerationContext)
+diff --git a/packages/next/src/server/use-cache/use-cache-probe-globals.ts b/packages/next/src/server/use-cache/use-cache-probe-globals.ts
+index 272e71d1a7..1f3b3a5f30 100644
+--- a/packages/next/src/server/use-cache/use-cache-probe-globals.ts
++++ b/packages/next/src/server/use-cache/use-cache-probe-globals.ts
+@@ -24,6 +24,7 @@ export type UseCacheProbeRequestSnapshot = {
+   rootParams: Params
+   isDraftMode: boolean
+   isHmrRefresh: boolean
++  hmrRefreshHash: string | undefined
+ }
+ 
+ /**
+diff --git a/packages/next/src/server/use-cache/use-cache-probe-scheduler.ts b/packages/next/src/server/use-cache/use-cache-probe-scheduler.ts
+index f8733b7e8f..dbed303bda 100644
+--- a/packages/next/src/server/use-cache/use-cache-probe-scheduler.ts
++++ b/packages/next/src/server/use-cache/use-cache-probe-scheduler.ts
+@@ -115,6 +115,7 @@ export function setupProbeScheduler(
+         rootParams: outerRequestStore.rootParams ?? {},
+         isDraftMode: workStore.isDraftMode ?? false,
+         isHmrRefresh: outerRequestStore.isHmrRefresh ?? false,
++        hmrRefreshHash: outerRequestStore.hmrRefreshHash,
+       },
+       timeoutMs: probeInternalTimeoutMs,
+     }).then(
+diff --git a/packages/next/src/server/use-cache/use-cache-wrapper.ts b/packages/next/src/server/use-cache/use-cache-wrapper.ts
+index 2bebc96297..f549de8b8d 100644
+--- a/packages/next/src/server/use-cache/use-cache-wrapper.ts
++++ b/packages/next/src/server/use-cache/use-cache-wrapper.ts
+@@ -74,10 +74,7 @@ import {
+ } from './handlers'
+ import type { CacheReadWriteHandler } from './tiered-cache-handler'
+ import { cloneCacheEntry } from './clone-cache-entry'
+-import {
+-  NEXT_HMR_REFRESH_HASH_COOKIE,
+-  NEXT_INSTANT_TEST_COOKIE,
+-} from '../../client/components/app-router-headers'
++import { NEXT_INSTANT_TEST_COOKIE } from '../../client/components/app-router-headers'
+ import type { ReadonlyRequestCookies } from '../web/spec-extension/adapters/request-cookies'
+ import type { ReadonlyHeaders } from '../web/spec-extension/adapters/headers'
+ import {
+@@ -366,10 +363,8 @@ function computeRootParamsCacheKeySuffix(
+ // Next-internal cookies that must not vary the private cache key, since they're
+ // not part of the application's own cookie state. The instant-navigation cookie
+ // toggles while a navigation lock is held, so including it would force spurious
+-// misses. The HMR refresh hash is already part of the cache key (see
+-// `cacheKeyParts`), so including its cookie too would just be redundant.
++// misses.
+ const COOKIES_EXCLUDED_FROM_PRIVATE_CACHE_KEY = new Set<string>([
+-  NEXT_HMR_REFRESH_HASH_COOKIE,
+   NEXT_INSTANT_TEST_COOKIE,
+ ])
+ 
+diff --git a/packages/next/src/server/web/adapter.ts b/packages/next/src/server/web/adapter.ts
+index 38c960b804..c9c2a43ac3 100644
+--- a/packages/next/src/server/web/adapter.ts
++++ b/packages/next/src/server/web/adapter.ts
+@@ -313,7 +313,10 @@ export async function adapter(
+               request.nextUrl,
+               implicitTags,
+               onUpdateCookies,
+-              previewProps
++              previewProps,
++              // Edge route handlers can't use `"use cache"`, so there's no HMR
++              // refresh hash to thread through here.
++              undefined
+             )
+ 
+             const workStore = createWorkStore({

nextjs-96022-dev-use-cache-invalidation/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch

nextjs-96022-dev-use-cache-invalidation/tests/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack install --global pnpm@10.33.0 && NEXT_SKIP_NATIVE_POSTINSTALL=0 pnpm install --frozen-lockfile && TURBO_TASKS_AVAILABLE_PARALLELISM=4 ANALYZE=1 pnpm build && pnpm exec playwright install --with-deps chromium && chmod -R a+rwX packages/next' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app

nextjs-96022-dev-use-cache-invalidation/tests/test.patch

@@ -0,0 +1,61 @@
+diff --git a/test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts b/test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts
+index da4e0a22..ca835118 100644
+--- a/test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts
++++ b/test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts
+@@ -108,15 +108,11 @@ describe('use-cache-dev', () => {
+       )
+     })
+ 
+-    // These two currently fail in both Turbopack and Webpack. Dev "use cache"
+-    // invalidation relies on the __next_hmr_refresh_hash__ cookie that the
+-    // browser HMR client sets after an edit; a client that fetches directly
+-    // (curl, a plain fetch, a second device) never sends that cookie, so the
+-    // "use cache" key does not change across the edit and the stale entry is
+-    // reused. Change these to `it` once editing a file invalidates cached data
+-    // for requests that do not carry the cookie, covering both route handlers
+-    // and pages.
+-    it.failing(
++    // Regression coverage for requesters that don't run the browser HMR client.
++    // A direct requester never receives browser-authored refresh state, but it
++    // must still observe a new cache generation after the server recompiles an
++    // edited page or route handler.
++    it(
+       'should update cached data used by a route handler after editing a file',
+       async () => {
+         const initialData = await next
+@@ -160,10 +156,20 @@ describe('use-cache-dev', () => {
+         // random value due to a cache miss.
+         expect(newData.text).toBe('bar')
+         expect(newData.mathRandom).not.toBe(initialData.mathRandom)
++
++        // Once the edited module has compiled, ordinary warm requests should
++        // keep reusing its new cache entry rather than advancing the cache key
++        // for development bookkeeping.
++        const warmData = await next
++          .fetch('/api/cached')
++          .then((res) => res.json())
++
++        expect(warmData.text).toBe('bar')
++        expect(warmData.mathRandom).toBe(newData.mathRandom)
+       }
+     )
+ 
+-    it.failing(
++    it(
+       'should update cached data used by a page fetched without a cookie after editing a file',
+       async () => {
+         // `next.render$` fetches directly, without the browser HMR client, so
+@@ -202,6 +208,13 @@ describe('use-cache-dev', () => {
+         // random value due to a cache miss.
+         expect($('#text').text()).toBe('bar')
+         expect($('#mathRandom').text()).not.toBe(initialMathRandom)
++
++        // The post-edit value should remain cached on another direct request.
++        const editedMathRandom = $('#mathRandom').text()
++        $ = await next.render$('/cached-page')
++
++        expect($('#text').text()).toBe('bar')
++        expect($('#mathRandom').text()).toBe(editedMathRandom)
+       }
+     )
+ 

nextjs-96022-dev-use-cache-invalidation/tests/test.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts' --exclude='test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  git -C /app restore --source=HEAD --staged --worktree -- 'test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts' >/dev/null 2>&1 || true
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'git diff --name-only -z -- packages/next | while IFS= read -r -d '"'"''"'"' file; do if [ -f "$file" ] && [ ! -w "$file" ]; then cp -- "$file" "$file.selfbench-tmp" && mv -- "$file.selfbench-tmp" "$file"; fi; done && TURBO_TASKS_AVAILABLE_PARALLELISM=4 pnpm build && pnpm test-dev-turbo '"'"'test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'git diff --name-only -z -- packages/next | while IFS= read -r -d '"'"''"'"' file; do if [ -f "$file" ] && [ ! -w "$file" ]; then cp -- "$file" "$file.selfbench-tmp" && mv -- "$file.selfbench-tmp" "$file"; fi; done && TURBO_TASKS_AVAILABLE_PARALLELISM=4 pnpm build && pnpm test-dev-turbo '"'"'test/e2e/app-dir/use-cache-dev/use-cache-dev.test.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'git diff --name-only -z -- packages/next | while IFS= read -r -d '"'"''"'"' file; do if [ -f "$file" ] && [ ! -w "$file" ]; then cp -- "$file" "$file.selfbench-tmp" && mv -- "$file.selfbench-tmp" "$file"; fi; done && TURBO_TASKS_AVAILABLE_PARALLELISM=4 pnpm build && pnpm test-dev-turbo '"'"'test/development/app-dir/basic/basic.test.ts'"'"' '"'"'test/development/app-dir/multiple-compiles-single-route/multiple-compiles-single-route.test.ts'"'"''; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0

nextjs-byte-budgeted-lru-keys/environment/Dockerfile

@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack prepare pnpm@10.33.0 --activate && mkdir -p .selfbench-bin && corepack enable --install-directory "$PWD/.selfbench-bin" && PATH="$PWD/.selfbench-bin:$PATH" NEXT_TELEMETRY_DISABLED=1 pnpm install --frozen-lockfile && PATH="$PWD/.selfbench-bin:$PATH" NEXT_TELEMETRY_DISABLED=1 ANALYZE=1 pnpm build' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app

nextjs-byte-budgeted-lru-keys/solution/gold.patch

@@ -0,0 +1,117 @@
+diff --git a/packages/next/src/server/dev/next-dev-server.ts b/packages/next/src/server/dev/next-dev-server.ts
+index 388dd82b9e..14dbe16304 100644
+--- a/packages/next/src/server/dev/next-dev-server.ts
++++ b/packages/next/src/server/dev/next-dev-server.ts
+@@ -195,9 +195,11 @@ export default class DevServer extends Server {
+     this.staticPathsCache = new LRUCache(
+       // 5MB
+       5 * 1024 * 1024,
+-      function length(value) {
++      function length(value, cacheKey) {
+         // Ensure minimum size of 1 for LRU eviction to work correctly
+-        return JSON.stringify(value.staticPaths)?.length || 1
++        return (
++          cacheKey.length + (JSON.stringify(value.staticPaths)?.length || 1)
++        )
+       }
+     )
+ 
+@@ -214,8 +216,8 @@ export default class DevServer extends Server {
+       )
+       this.serverComponentsHmrCache = new LRUCache(
+         hmrCacheSize,
+-        function length(value) {
+-          return JSON.stringify(value).length
++        function length(value, cacheKey) {
++          return cacheKey.length + JSON.stringify(value).length
+         }
+       )
+     }
+diff --git a/packages/next/src/server/lib/cache-handlers/default.ts b/packages/next/src/server/lib/cache-handlers/default.ts
+index 112c41a203..b188176d98 100644
+--- a/packages/next/src/server/lib/cache-handlers/default.ts
++++ b/packages/next/src/server/lib/cache-handlers/default.ts
+@@ -58,7 +58,7 @@ export function createDefaultCacheHandler(maxSize: number): CacheHandler {
+ 
+   const memoryCache = new LRUCache<PrivateCacheEntry>(
+     maxSize,
+-    (entry) => entry.size
++    (entry, cacheKey) => entry.size + cacheKey.length
+   )
+   const pendingSets = new Map<string, Promise<void>>()
+ 
+diff --git a/packages/next/src/server/lib/incremental-cache/memory-cache.external.ts b/packages/next/src/server/lib/incremental-cache/memory-cache.external.ts
+index e446656409..d9f66ba850 100644
+--- a/packages/next/src/server/lib/incremental-cache/memory-cache.external.ts
++++ b/packages/next/src/server/lib/incremental-cache/memory-cache.external.ts
+@@ -24,30 +24,37 @@ function getSegmentDataSize(segmentData: Map<string, Buffer> | undefined) {
+ 
+ export function getMemoryCache(maxMemoryCacheSize: number) {
+   if (!memoryCache) {
+-    memoryCache = new LRUCache(maxMemoryCacheSize, function length({ value }) {
++    memoryCache = new LRUCache(maxMemoryCacheSize, function length(
++      { value },
++      cacheKey
++    ) {
++      let valueSize: number
++
+       if (!value) {
+-        return 25
++        valueSize = 25
+       } else if (value.kind === CachedRouteKind.REDIRECT) {
+-        return JSON.stringify(value.props).length
++        valueSize = JSON.stringify(value.props).length
+       } else if (value.kind === CachedRouteKind.IMAGE) {
+         throw new Error('invariant image should not be incremental-cache')
+       } else if (value.kind === CachedRouteKind.FETCH) {
+-        return JSON.stringify(value.data || '').length
++        valueSize = JSON.stringify(value.data || '').length
+       } else if (value.kind === CachedRouteKind.APP_ROUTE) {
+-        return value.body.length
+-      }
+-      // rough estimate of size of cache value
+-      if (value.kind === CachedRouteKind.APP_PAGE) {
+-        return Math.max(
++        valueSize = value.body.length
++      } else if (value.kind === CachedRouteKind.APP_PAGE) {
++        // rough estimate of size of cache value
++        valueSize = Math.max(
+           1,
+           value.html.length +
+             getBufferSize(value.rscData) +
+             (value.postponed?.length || 0) +
+             getSegmentDataSize(value.segmentData)
+         )
++      } else {
++        valueSize =
++          value.html.length + (JSON.stringify(value.pageData)?.length || 0)
+       }
+ 
+-      return value.html.length + (JSON.stringify(value.pageData)?.length || 0)
++      return cacheKey.length + valueSize
+     })
+   }
+ 
+diff --git a/packages/next/src/server/lib/source-maps.ts b/packages/next/src/server/lib/source-maps.ts
+index af2969c03e..654de4126e 100644
+--- a/packages/next/src/server/lib/source-maps.ts
++++ b/packages/next/src/server/lib/source-maps.ts
+@@ -215,13 +215,13 @@ function bundlerFindSourceMapURL(scriptNameOrSourceURL: string): string | null {
+ const invalidSourceMap = Symbol('invalid-source-map')
+ const sourceMapURLs = new LRUCache<string | typeof invalidSourceMap>(
+   512 * 1024 * 1024,
+-  (url) =>
+-    url === invalidSourceMap
+-      ? // Ideally we'd account for key length. So we just guestimate a small source map
+-        // so that we don't create a huge cache with empty source maps.
++  (url, sourceURL) =>
++    sourceURL.length +
++    (url === invalidSourceMap
++      ? // Guestimate a small source map so invalid entries don't fill the cache.
+         8 * 1024
+       : // these URLs contain only ASCII characters so .length is equal to Buffer.byteLength
+-        url.length
++        url.length)
+ )
+ export function findSourceMapURLDEV(
+   scriptNameOrSourceURL: string

nextjs-byte-budgeted-lru-keys/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch

nextjs-byte-budgeted-lru-keys/tests/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack prepare pnpm@10.33.0 --activate && mkdir -p .selfbench-bin && corepack enable --install-directory "$PWD/.selfbench-bin" && PATH="$PWD/.selfbench-bin:$PATH" NEXT_TELEMETRY_DISABLED=1 pnpm install --frozen-lockfile && PATH="$PWD/.selfbench-bin:$PATH" NEXT_TELEMETRY_DISABLED=1 ANALYZE=1 pnpm build' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app

nextjs-byte-budgeted-lru-keys/tests/test.patch

@@ -0,0 +1,243 @@
+diff --git a/packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts b/packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts
+new file mode 100644
+index 0000000000..4cb91c9136
+--- /dev/null
++++ b/packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts
+@@ -0,0 +1,237 @@
++import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs'
++import type { SourceMap } from 'module'
++import { tmpdir } from 'os'
++import { join } from 'path'
++import DevServer from 'next/dist/server/dev/next-dev-server'
++import { defaultConfig } from 'next/dist/server/config-shared'
++import type { CacheEntry } from './cache-handlers/types'
++import { createDefaultCacheHandler } from './cache-handlers/default'
++import { getMemoryCache } from './incremental-cache/memory-cache.external'
++
++function cacheEntry(body: string): CacheEntry {
++  return {
++    value: new ReadableStream({
++      start(controller) {
++        controller.enqueue(new TextEncoder().encode(body))
++        controller.close()
++      },
++    }),
++    tags: [],
++    stale: 60,
++    timestamp: Date.now(),
++    expire: 60,
++    revalidate: 60,
++  }
++}
++
++class TestDevServer extends DevServer {
++  readStaticPaths(pathname: string) {
++    return this.getStaticPaths({
++      pathname,
++      urlPathname: pathname,
++      requestHeaders: {},
++      page: '/[slug]',
++      isAppPath: false,
++    })
++  }
++
++  hmrCache() {
++    return this.getServerComponentsHmrCache()
++  }
++}
++
++describe('byte-budgeted server caches', () => {
++  it('charges incremental-cache keys against the memory budget', () => {
++    const cache = getMemoryCache(64)
++    const key = `/api/data?${'p'.repeat(80)}`
++    const warning = jest.spyOn(console, 'warn').mockImplementation()
++
++    cache?.set(key, {
++      value: { kind: 'FETCH', data: { body: 'ok' } },
++      lastModified: 1,
++    } as any)
++
++    warning.mockRestore()
++    expect(cache?.get(key)).toBeUndefined()
++  })
++
++  it('charges use-cache keys against the default handler budget', async () => {
++    const handler = createDefaultCacheHandler(16)
++    const key = `cache-${'k'.repeat(32)}`
++    const warning = jest.spyOn(console, 'warn').mockImplementation()
++
++    await handler.set(key, Promise.resolve(cacheEntry('x')))
++
++    warning.mockRestore()
++    expect(await handler.get(key, [])).toBeUndefined()
++  })
++
++  it('charges route keys against the development static paths budget', async () => {
++    const dir = mkdtempSync(join(tmpdir(), 'next-static-paths-cache-'))
++    mkdirSync(join(dir, 'pages'))
++    mkdirSync(join(dir, '.next', 'server', 'pages'), { recursive: true })
++    writeFileSync(
++      join(dir, '.next', 'prerender-manifest.json'),
++      JSON.stringify({
++        version: 4,
++        routes: {},
++        dynamicRoutes: {},
++        notFoundRoutes: [],
++        preview: {
++          previewModeId: 'a'.repeat(32),
++          previewModeSigningKey: 'b'.repeat(64),
++          previewModeEncryptionKey: 'c'.repeat(32),
++        },
++      })
++    )
++    writeFileSync(join(dir, '.next', 'build-manifest.json'), '{}')
++    writeFileSync(join(dir, '.next', 'react-loadable-manifest.json'), '{}')
++    writeFileSync(
++      join(dir, '.next', 'server', 'pages-manifest.json'),
++      JSON.stringify({
++        '/_document': 'pages/_document.js',
++        '/_app': 'pages/_app.js',
++        '/[slug]': 'pages/[slug].js',
++      })
++    )
++    writeFileSync(
++      join(dir, '.next', 'server', 'pages', '_document.js'),
++      'module.exports={default:()=>null}'
++    )
++    writeFileSync(
++      join(dir, '.next', 'server', 'pages', '_app.js'),
++      'module.exports={default:()=>null}'
++    )
++    const counter = join(dir, 'counter')
++    writeFileSync(counter, '0')
++    writeFileSync(
++      join(dir, '.next', 'server', 'pages', '[slug].js'),
++      `const fs=require('fs');const p=${JSON.stringify(
++        counter
++      )};module.exports={default:()=>null,getStaticProps:async()=>({props:{}}),getStaticPaths:async()=>{const n=+fs.readFileSync(p,'utf8')+1;fs.writeFileSync(p,String(n));return {paths:['/generated-'+n],fallback:false}}}`
++    )
++
++    try {
++      const server = new TestDevServer({
++        dir,
++        conf: {
++          ...defaultConfig,
++          experimental: {
++            ...defaultConfig.experimental,
++            instantInsights: { validationLevel: 'warning' },
++            useCacheTimeout: 50,
++            turbopackMemoryEvictionMode: 'auto',
++          },
++        },
++        bundlerService: {
++          getServerComponentsHmrRefreshHash: () => '',
++          sendHmrMessage: jest.fn(),
++        } as any,
++        startServerSpan: undefined as any,
++      })
++      const parameterName = 'p'.repeat(3 * 1024 * 1024)
++      const first = `/[${parameterName}a]`
++      const second = `/[${parameterName}b]`
++
++      await server.readStaticPaths(first)
++      await server.readStaticPaths(second)
++      const refreshed = await server.readStaticPaths(first)
++
++      for (let i = 0; i < 100 && Number(readFileSync(counter)) < 3; i++) {
++        await new Promise((resolve) => setTimeout(resolve, 10))
++      }
++      await new Promise((resolve) => setTimeout(resolve, 100))
++      expect(refreshed.staticPaths).toEqual(['/generated-3'])
++    } finally {
++      rmSync(dir, { recursive: true, force: true })
++    }
++  })
++
++  it('charges module keys against the development HMR cache budget', () => {
++    const dir = mkdtempSync(join(tmpdir(), 'next-dev-cache-'))
++    mkdirSync(join(dir, 'pages'))
++    mkdirSync(join(dir, '.next'))
++    writeFileSync(
++      join(dir, '.next', 'prerender-manifest.json'),
++      JSON.stringify({
++        version: 4,
++        routes: {},
++        dynamicRoutes: {},
++        notFoundRoutes: [],
++        preview: {
++          previewModeId: 'a'.repeat(32),
++          previewModeSigningKey: 'b'.repeat(64),
++          previewModeEncryptionKey: 'c'.repeat(32),
++        },
++      })
++    )
++
++    try {
++      const server = new TestDevServer({
++        dir,
++        conf: {
++          ...defaultConfig,
++          experimental: {
++            ...defaultConfig.experimental,
++            serverComponentsHmrCache: true,
++            instantInsights: { validationLevel: 'warning' },
++            useCacheTimeout: 50,
++            turbopackMemoryEvictionMode: 'auto',
++          },
++        },
++        bundlerService: {
++          getServerComponentsHmrRefreshHash: () => '',
++          sendHmrMessage: jest.fn(),
++        } as any,
++        startServerSpan: undefined as any,
++      })
++      const cache = server.hmrCache()
++      const prefix = 'm'.repeat(30 * 1024 * 1024)
++      const first = `${prefix}-first`
++      const second = `${prefix}-second`
++
++      cache!.set(first, ['first'] as any)
++      cache!.set(second, ['second'] as any)
++
++      expect(cache!.get(first)).toBeUndefined()
++      expect(cache!.get(second)).toEqual(['second'])
++    } finally {
++      rmSync(dir, { recursive: true, force: true })
++    }
++  })
++
++  it('eventually revisits old source-map misses when URL keys fill the budget', () => {
++    jest.resetModules()
++    const nodeModule = jest.requireActual<typeof import('module')>('module')
++    const available = new Map<string, SourceMap>()
++    const findSourceMap = jest
++      .spyOn(nodeModule, 'findSourceMap')
++      .mockImplementation((sourceURL) => available.get(sourceURL))
++
++    let sourceMaps!: typeof import('./source-maps')
++    jest.isolateModules(() => {
++      sourceMaps = require('./source-maps')
++    })
++
++    const original = 'server-entry.js'
++    expect(sourceMaps.findSourceMapURLDEV(original)).toBeNull()
++
++    for (let i = 0; i < 65_535; i++) {
++      sourceMaps.findSourceMapURLDEV(`chunk-${i}-${'x'.repeat(96)}`)
++    }
++
++    available.set(original, {
++      payload: {
++        version: 3,
++        file: original,
++        sources: ['server-entry.ts'],
++        names: [],
++        mappings: '',
++      },
++    } as SourceMap)
++
++    const refreshed = sourceMaps.findSourceMapURLDEV(original)
++    findSourceMap.mockRestore()
++    expect(refreshed).toMatch(/^data:application\/json;base64,/)
++  })
++})

nextjs-byte-budgeted-lru-keys/tests/test.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts' --exclude='packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  git -C /app restore --source=HEAD --staged --worktree -- 'packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts' >/dev/null 2>&1 || true
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'PATH="$PWD/.selfbench-bin:$PATH" NEXT_TELEMETRY_DISABLED=1 ANALYZE=1 pnpm build && PATH="$PWD/.selfbench-bin:$PATH" NEXT_TELEMETRY_DISABLED=1 pnpm test '"'"'packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'PATH="$PWD/.selfbench-bin:$PATH" NEXT_TELEMETRY_DISABLED=1 ANALYZE=1 pnpm build && PATH="$PWD/.selfbench-bin:$PATH" NEXT_TELEMETRY_DISABLED=1 pnpm test '"'"'packages/next/src/server/lib/byte-budgeted-cache-keys.test.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'true'; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0

nextjs-byte-exact-binary-fetch-cache-keys/tests/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && pnpm install --frozen-lockfile && ANALYZE=1 pnpm build' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app

nextjs-byte-exact-binary-fetch-cache-keys/tests/test.patch

@@ -0,0 +1,258 @@
+diff --git a/test/unit/incremental-cache/generate-cache-key.test.ts b/test/unit/incremental-cache/generate-cache-key.test.ts
+new file mode 100644
+index 00000000..f320376b
+--- /dev/null
++++ b/test/unit/incremental-cache/generate-cache-key.test.ts
+@@ -0,0 +1,252 @@
++import { IncrementalCache } from '../../../packages/next/src/server/lib/incremental-cache'
++
++function createCache() {
++  return new IncrementalCache({
++    dev: false,
++    requestHeaders: {},
++    getPrerenderManifest: () =>
++      ({
++        version: 4,
++        routes: {},
++        dynamicRoutes: {},
++        notFoundRoutes: [],
++        preview: {
++          previewModeId: 'id',
++          previewModeSigningKey: 'key',
++          previewModeEncryptionKey: 'key',
++        },
++      }) as any,
++  })
++}
++
++describe('IncrementalCache.generateCacheKey', () => {
++  const cache = createCache()
++  const url = 'https://example.com/api'
++
++  it('distinguishes binary bodies that UTF-8 decoding would collapse', async () => {
++    // 0xff and 0xfe both decode to U+FFFD as UTF-8; the key must tell them
++    // apart by their raw bytes.
++    const a = await cache.generateCacheKey(url, {
++      body: new Uint8Array([0xff]),
++    })
++    const b = await cache.generateCacheKey(url, {
++      body: new Uint8Array([0xfe]),
++    })
++    expect(a).not.toBe(b)
++  })
++
++  it('distinguishes a string body from its UTF-8 encoded bytes', async () => {
++    // A string and the bytes it encodes to are different request shapes.
++    const a = await cache.generateCacheKey(url, { body: 'hello' })
++    const b = await cache.generateCacheKey(url, {
++      body: new TextEncoder().encode('hello'),
++    })
++    expect(a).not.toBe(b)
++  })
++
++  it('uses the selected bytes of arbitrary ArrayBuffer views', async () => {
++    const backing = new Uint8Array([9, 1, 2, 3, 9])
++    const dataView = new DataView(backing.buffer, 1, 3)
++    const typedView = new Uint8Array([1, 2, 3])
++
++    const a = await cache.generateCacheKey(url, { body: dataView })
++    const b = await cache.generateCacheKey(url, { body: typedView })
++    expect(a).toBe(b)
++  })
++
++  it('distinguishes URLSearchParams, FormData, and string bodies', async () => {
++    const form = new FormData()
++    form.append('x', 'a')
++
++    const formKey = await cache.generateCacheKey(url, { body: form })
++    const paramsKey = await cache.generateCacheKey(url, {
++      body: new URLSearchParams([['x', 'a']]),
++    })
++    const stringKey = await cache.generateCacheKey(url, { body: 'x=a' })
++
++    expect(new Set([formKey, paramsKey, stringKey]).size).toBe(3)
++  })
++
++  it('distinguishes a Blob from its raw content bytes', async () => {
++    const bytes = new Uint8Array([1, 2, 3])
++    const blobKey = await cache.generateCacheKey(url, {
++      body: new Blob([bytes]),
++    })
++    const bytesKey = await cache.generateCacheKey(url, { body: bytes })
++
++    expect(blobKey).not.toBe(bytesKey)
++  })
++
++  it('is deterministic for identical bodies', async () => {
++    const a = await cache.generateCacheKey(url, {
++      body: new Uint8Array([1, 2, 3]),
++    })
++    const b = await cache.generateCacheKey(url, {
++      body: new Uint8Array([1, 2, 3]),
++    })
++    expect(a).toBe(b)
++  })
++
++  it('does not collide FormData multi-values with a comma-joined string', async () => {
++    // The two values ['a', 'b'] must not hash the same as the single 'a,b'.
++    const multi = new FormData()
++    multi.append('x', 'a')
++    multi.append('x', 'b')
++
++    const joined = new FormData()
++    joined.append('x', 'a,b')
++
++    const a = await cache.generateCacheKey(url, { body: multi })
++    const b = await cache.generateCacheKey(url, { body: joined })
++    expect(a).not.toBe(b)
++  })
++
++  it('distinguishes blobs that differ only by content type', async () => {
++    const bytes = new Uint8Array([1, 2, 3])
++    const a = await cache.generateCacheKey(url, {
++      body: new Blob([bytes], { type: 'text/plain' }),
++    })
++    const b = await cache.generateCacheKey(url, {
++      body: new Blob([bytes], { type: 'application/json' }),
++    })
++    expect(a).not.toBe(b)
++  })
++
++  it('distinguishes ArrayBuffers', async () => {
++    const a = await cache.generateCacheKey(url, {
++      body: new Uint8Array([1, 2, 3, 4]).buffer,
++    })
++    const b = await cache.generateCacheKey(url, {
++      body: new Uint8Array([1, 2, 3]).buffer,
++    })
++    expect(a).not.toBe(b)
++  })
++
++  it('produces the same key for identical bytes in different typed arrays', async () => {
++    const uint8View = new Uint8Array([1, 2, 3, 4])
++    const uint16View = new Uint16Array(
++      uint8View.buffer,
++      uint8View.byteOffset,
++      uint8View.byteLength / 2
++    )
++    const a = await cache.generateCacheKey(url, {
++      body: uint8View,
++    })
++    const b = await cache.generateCacheKey(url, {
++      body: uint16View,
++    })
++    expect(a).toBe(b)
++  })
++
++  it('does not collide FormData with differently interleaved values', async () => {
++    const a = new FormData()
++    a.append('x', 'a')
++    a.append('x', 'b')
++    a.append('y', 'a')
++
++    const b = new FormData()
++    b.append('x', 'a')
++    b.append('y', 'a')
++    b.append('x', 'b')
++
++    const keyA = await cache.generateCacheKey(url, { body: a })
++    const keyB = await cache.generateCacheKey(url, { body: b })
++    expect(keyA).not.toBe(keyB)
++  })
++
++  it('does not collide FormData whose value forges quoted entry delimiters', async () => {
++    // User values may resemble framing text and must remain data.
++    const a = new FormData()
++    a.append('x', 'a"key:"y"str:"b')
++
++    const b = new FormData()
++    b.append('x', 'a')
++    b.append('y', 'b')
++
++    const keyA = await cache.generateCacheKey(url, { body: a })
++    const keyB = await cache.generateCacheKey(url, { body: b })
++    expect(keyA).not.toBe(keyB)
++  })
++
++  it('does not collide FormData whose value spans an entry boundary', async () => {
++    // One value may contain text resembling a complete following entry.
++    const a = new FormData()
++    a.append('x', 'akey:ystr:b')
++
++    const b = new FormData()
++    b.append('x', 'a')
++    b.append('y', 'b')
++
++    const keyA = await cache.generateCacheKey(url, { body: a })
++    const keyB = await cache.generateCacheKey(url, { body: b })
++    expect(keyA).not.toBe(keyB)
++  })
++
++  it('does not collide FormData files that differ only by name/type split', async () => {
++    // File name and content type are separate fetch-relevant metadata.
++    const bytes = new Uint8Array([1, 2, 3])
++
++    const a = new FormData()
++    a.append('f', new Blob([bytes], { type: 'c' }), 'ab')
++
++    const b = new FormData()
++    b.append('f', new Blob([bytes], { type: 'bc' }), 'a')
++
++    const keyA = await cache.generateCacheKey(url, { body: a })
++    const keyB = await cache.generateCacheKey(url, { body: b })
++    expect(keyA).not.toBe(keyB)
++  })
++
++  it('does not collide a file whose content forges a following entry', async () => {
++    // File bytes may resemble framing for a following field.
++    const enc = new TextEncoder()
++
++    const a = new FormData()
++    a.append('f', new Blob([enc.encode('AAAkey:1kstr:1v')], { type: '' }), 'n')
++
++    const b = new FormData()
++    b.append('f', new Blob([enc.encode('AAA')], { type: '' }), 'n')
++    b.append('k', 'v')
++
++    const keyA = await cache.generateCacheKey(url, { body: a })
++    const keyB = await cache.generateCacheKey(url, { body: b })
++    expect(keyA).not.toBe(keyB)
++  })
++
++  it('does not collide blobs that differ only by type/content split', async () => {
++    // Blob content types and bytes must be framed as separate values.
++    const enc = new TextEncoder()
++
++    const a = new Blob([enc.encode('y')], { type: 'bytes:x' })
++    const b = new Blob([enc.encode('xbytes:y')], { type: '' })
++
++    const keyA = await cache.generateCacheKey(url, { body: a })
++    const keyB = await cache.generateCacheKey(url, { body: b })
++    expect(keyA).not.toBe(keyB)
++  })
++
++  it('does not collide a FormData value whose length digits absorb a forged entry', async () => {
++    // Length digits adjacent to user data must not make framing ambiguous.
++    const a = new FormData()
++    a.append('x', 'key:1astr:0')
++
++    const b = new FormData()
++    b.append('x', '1')
++    b.append('a', '')
++
++    const keyA = await cache.generateCacheKey(url, { body: a })
++    const keyB = await cache.generateCacheKey(url, { body: b })
++    expect(keyA).not.toBe(keyB)
++  })
++
++  it('does not collide blobs whose type-length digits absorb the content', async () => {
++    // Type lengths and content beginning with digits remain distinct.
++    const enc = new TextEncoder()
++    const a = new Blob([new Uint8Array(0)], { type: 'bytes:aaaaa' })
++    const b = new Blob([enc.encode('aaaaabytes:')], { type: '1' })
++
++    const keyA = await cache.generateCacheKey(url, { body: a })
++    const keyB = await cache.generateCacheKey(url, { body: b })
++    expect(keyA).not.toBe(keyB)
++  })
++})

nextjs-byte-exact-binary-fetch-cache-keys/tests/test.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='test/unit/incremental-cache/generate-cache-key.test.ts' --exclude='test/unit/incremental-cache/generate-cache-key.test.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  git -C /app restore --source=HEAD --staged --worktree -- 'test/unit/incremental-cache/generate-cache-key.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/unit/incremental-cache/generate-cache-key.test.ts' >/dev/null 2>&1 || true
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/test/unit/incremental-cache/generate-cache-key.test.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'pnpm test-webpack '"'"'test/unit/incremental-cache/generate-cache-key.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm test-webpack '"'"'test/unit/incremental-cache/generate-cache-key.test.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'pnpm test-webpack '"'"'test/unit/incremental-cache/file-system-cache.test.ts'"'"' '"'"'test/unit/stream-utils/uint8array-helpers.test.ts'"'"''; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0

nextjs-cache-short-expire-dev/environment/Dockerfile

@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && pnpm install --frozen-lockfile && ANALYZE=1 pnpm build && pnpm exec playwright install --with-deps chromium' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app

nextjs-cache-short-expire-dev/solution/gold.patch

@@ -0,0 +1,303 @@
+diff --git a/packages/next/src/server/lib/cache-handlers/default.ts b/packages/next/src/server/lib/cache-handlers/default.ts
+index 5a215994fe..0270c24b62 100644
+--- a/packages/next/src/server/lib/cache-handlers/default.ts
++++ b/packages/next/src/server/lib/cache-handlers/default.ts
+@@ -20,6 +20,7 @@ import {
+   tagsManifest,
+   type TagManifestEntry,
+ } from '../incremental-cache/tags-manifest.external'
++import { MIN_PRERENDERABLE_EXPIRE } from '../../use-cache/constants'
+ 
+ type PrivateCacheEntry = {
+   entry: CacheEntry
+@@ -83,10 +84,30 @@ export function createDefaultCacheHandler(maxSize: number): CacheHandler {
+ 
+       const entry = privateEntry.entry
+ 
++      // A negative `expire` is an eviction sentinel: the tiered cache handler
++      // (dev-only) marks a front entry for deletion by overwriting it with a
++      // negative `expire`, since the cache-handler interface has no per-key
++      // delete. Treat it as missing here, independently of the minimum
++      // retention below (which would otherwise keep it alive). This is distinct
++      // from `revalidate = -1` below, which keeps serving the entry but forces
++      // a revalidation.
++      if (entry.expire < 0) {
++        debug?.('get', cacheKey, 'evicted')
++        return undefined
++      }
++
+       // The dev server serves stale entries until they expire (see the file
+-      // overview); production drops them once past the revalidate time.
++      // overview); production drops them once past the revalidate time. In dev,
++      // an entry is retained for at least `MIN_PRERENDERABLE_EXPIRE` so that
++      // entries with a short `expire` (for example a `cacheLife({ expire: 0 })`
++      // client-only cache) still linger long enough that a reload hits the
++      // cache. That minimum is the same threshold below which the "use cache"
++      // wrapper treats an entry as dynamic, so it only extends the retention of
++      // entries that are dynamic anyway. It affects retention only; the
++      // returned entry keeps its real `expire`, so staging decisions are
++      // unchanged.
+       const maxAgeSeconds = process.env.__NEXT_DEV_SERVER
+-        ? entry.expire
++        ? Math.max(entry.expire, MIN_PRERENDERABLE_EXPIRE)
+         : entry.revalidate
+ 
+       if (
+diff --git a/packages/next/src/server/use-cache/handlers.ts b/packages/next/src/server/use-cache/handlers.ts
+index 8217c381ee..d9edb00284 100644
+--- a/packages/next/src/server/use-cache/handlers.ts
++++ b/packages/next/src/server/use-cache/handlers.ts
+@@ -107,26 +107,25 @@ export function initializeCacheHandlers(cacheMaxMemorySize: number): boolean {
+   // Create a set of the cache handlers.
+   reference[handlersSetSymbol] = new Set(handlersMap.values())
+ 
+-  // In development we add dedicated built-in in-memory handlers so that warm
+-  // reloads are fast. These are always built-in handlers, never a
+-  // user-configured one, and are gated on the dev server so production behaves
+-  // exactly as configured.
++  // In development we add dedicated built-in in-memory handlers so that reloads
++  // are fast. These are always built-in handlers, never a user-configured one,
++  // and are gated on the dev server so production behaves exactly as
++  // configured.
+   if (process.env.__NEXT_DEV_SERVER) {
+     reference[memoryCacheDisabledSymbol] = cacheMaxMemorySize === 0
+ 
+-    // Private caches are persisted here so warm reloads are fast. Private
+-    // entries can hold data specific to the incoming request (for example,
+-    // derived from its cookies or headers), so this is never the
+-    // user-configured `default` alias. Sized so it still caches under
+-    // `cacheMaxMemorySize: 0` (otherwise it would become the no-op stub and
+-    // private reloads would miss).
++    // Private caches are persisted here so reloads are fast. Private entries
++    // can hold data specific to the incoming request (for example, derived from
++    // its cookies or headers), so this is never the user-configured `default`
++    // alias. Sized so it still caches under `cacheMaxMemorySize: 0` (otherwise
++    // it would become the no-op stub and private reloads would miss).
+     reference[privateHandlerSymbol] = createDefaultCacheHandler(
+       DEV_MEMORY_CACHE_SIZE
+     )
+ 
+     // Built-in front handlers, one per custom kind, and the tiered handlers
+     // that place a front in front of a (possibly slow or remote) backing
+-    // handler so warm reads resolve in a microtask, are both created per kind
++    // handler so cache hits resolve in a microtask, are both created per kind
+     // in `setCacheHandler`.
+     reference[devFrontHandlersSymbol] = new Map()
+     reference[devTieredHandlersSymbol] = new Map()
+@@ -178,7 +177,7 @@ export function isMemoryCacheDisabled(): boolean {
+  * Whether `kind` is backed by a real user-configured handler rather than the
+  * built-in in-memory default. Such a handler may be slow or remote, so in
+  * development a built-in front handler is placed in front of it (see
+- * `getDevTieredCacheHandler`) to keep warm reads microtask-fast. The presence
++ * `getDevTieredCacheHandler`) to keep cache hits microtask-fast. The presence
+  * of a dev front handler is the signal, since front handlers are created
+  * exactly for user-registered kinds. Always `false` in production.
+  */
+@@ -193,7 +192,7 @@ export function isCustomCacheHandler(kind: string): boolean {
+ /**
+  * Get the dev-only tiered cache handler for a custom `kind`: a fast built-in
+  * in-memory front handler in front of the user-configured backing handler, so
+- * warm reads resolve in a microtask. Returns `undefined` if there is none (a
++ * cache hits resolve in a microtask. Returns `undefined` if there is none (a
+  * built-in kind, or production).
+  */
+ export function getDevTieredCacheHandler(
+@@ -307,11 +306,14 @@ export function setCacheHandler(
+   reference[handlersSetSymbol].add(cacheHandler)
+ 
+   // A user-configured handler may be slow or remote. In development, give it a
+-  // dedicated built-in in-memory front handler so warm reads resolve in a
++  // dedicated built-in in-memory front handler so cache hits resolve in a
+   // microtask, and pair the two into a tiered handler the wrapper reads
+   // through. Both are created alongside registration so their lifecycle matches
+   // the backing handler's, and the front handler's presence is the signal that
+-  // this kind is backed by a real handler (see `isCustomCacheHandler`).
++  // this kind is backed by a real handler (see `isCustomCacheHandler`). Being a
++  // built-in default handler, the front inherits the dev minimum retention, so
++  // a short-`expire` value still hits the front instead of falling through to
++  // the slow backing on every read.
+   if (process.env.__NEXT_DEV_SERVER) {
+     const frontHandler = createDefaultCacheHandler(DEV_MEMORY_CACHE_SIZE)
+     reference[devFrontHandlersSymbol]?.set(kind, frontHandler)
+diff --git a/packages/next/src/server/use-cache/tiered-cache-handler.ts b/packages/next/src/server/use-cache/tiered-cache-handler.ts
+index a73ba7e920..a5e8b3eeac 100644
+--- a/packages/next/src/server/use-cache/tiered-cache-handler.ts
++++ b/packages/next/src/server/use-cache/tiered-cache-handler.ts
+@@ -14,7 +14,7 @@ export type CacheReadWriteHandler = Pick<CacheHandler, 'get' | 'set'>
+ /**
+  * Development-only. Puts a fast built-in in-memory `front` handler in front of
+  * a slower or persistent user-configured `backing` handler. Its only job is to
+- * guarantee that warm reads resolve in a microtask (so they aren't counted as
++ * guarantee that cache hits resolve in a microtask (so they aren't counted as
+  * cache misses at a staged-render boundary, which would otherwise surface a
+  * cold cache indicator), while keeping the front in sync with the backing.
+  *
+@@ -76,9 +76,9 @@ export function createTieredCacheHandler(
+       const frontEntry = await front.get(cacheKey, softTags)
+ 
+       if (frontEntry) {
+-        // Warm hit: serve immediately (in a microtask). A background reconcile
++        // Cache hit: serve immediately (in a microtask). A background reconcile
+         // keeps the front in sync with the backing for the next read;
+-        // reconciles for the same key are serialized, so concurrent warm reads
++        // reconciles for the same key are serialized, so concurrent cache hits
+         // don't hit the backing in parallel.
+         scheduleBackgroundSync(cacheKey, () =>
+           reconcileFrontFromBacking(
+@@ -104,7 +104,7 @@ export function createTieredCacheHandler(
+       }
+ 
+       // Mirror this freshly read backing entry into the front so the next read
+-      // is warm. The mirror is serialized per key: if a sync is already
++      // hits it. The mirror is serialized per key: if a sync is already
+       // running, this chains after it, so the front converges to this read even
+       // if the backing changed since that sync started.
+       const [servedEntry, mirroredEntry] = cloneCacheEntry(backingEntry)
+@@ -130,9 +130,9 @@ export function createTieredCacheHandler(
+ }
+ 
+ /**
+- * After serving a warm front hit, consult the backing and mirror a newer entry
+- * into the front for the next read. Runs in the background; failures are
+- * non-fatal.
++ * After serving a cache hit from the front, consult the backing and mirror a
++ * newer entry into the front for the next read. Runs in the background;
++ * failures are non-fatal.
+  */
+ async function reconcileFrontFromBacking(
+   front: CacheHandler,
+@@ -186,17 +186,18 @@ async function mirrorIntoFront(
+ 
+ /**
+  * Build an already-expired copy of an entry, used to evict it from the front
+- * handler (which has no per-key delete) once the backing no longer has it. In
+- * dev the default handler treats an entry as missing once `now > timestamp +
+- * expire * 1000`, so `expire: 0` against the original (past) timestamp makes
+- * the next read a miss. The value is never read once the entry is expired, but
+- * it must carry at least one byte because the built-in LRU cache refuses to
+- * store size-0 entries.
++ * handler (which has no per-key delete) once the backing no longer has it. The
++ * default handler treats a negative `expire` as an eviction sentinel and
++ * reports the entry as missing on the next read. A negative `expire` is used
++ * rather than `0` because the dev front handler enforces a minimum retention,
++ * so a `0` `expire` would be kept alive by that minimum instead of evicted. The
++ * value is never read once the entry is evicted, but it must carry at least one
++ * byte because the built-in LRU cache refuses to store size-0 entries.
+  */
+ function toExpiredEntry(entry: CacheEntry): CacheEntry {
+   return {
+     ...entry,
+-    expire: 0,
++    expire: -1,
+     value: new ReadableStream({
+       start(controller) {
+         controller.enqueue(new Uint8Array(1))
+diff --git a/packages/next/src/server/use-cache/use-cache-wrapper.ts b/packages/next/src/server/use-cache/use-cache-wrapper.ts
+index 9dfddda9d4..3ca4a061e8 100644
+--- a/packages/next/src/server/use-cache/use-cache-wrapper.ts
++++ b/packages/next/src/server/use-cache/use-cache-wrapper.ts
+@@ -1092,12 +1092,17 @@ async function collectResult(
+   // `MIN_PRERENDERABLE_EXPIRE` (5 minutes) caps how long an entry lingers in
+   // the dedicated in-memory private handler. It is the shortest `expire` that
+   // isn't treated as dynamic; a smaller `expire` would exclude the entry from
+-  // prerenders. The size-0 case (`cacheMaxMemorySize: 0`) deliberately does NOT
+-  // force this: it keeps its resolved cache life so that the cache entry can be
+-  // considered prerenderable instead of being misread as a dynamic hole, and a
+-  // separate dev revalidation (see the cache-hit path below) keeps its reloads
+-  // showing a fresh value. Custom kinds keep their real cache life too, since
+-  // their backing handler owns it.
++  // prerenders. Two other cases deliberately do NOT force this and keep their
++  // resolved cache life, relying instead on the dev handler's minimum retention
++  // and a dev revalidation (see the cache-hit path below) to keep reloads fast
++  // and fresh. The size-0 case (`cacheMaxMemorySize: 0`) keeps its life so the
++  // entry can be considered prerenderable instead of being misread as a dynamic
++  // hole. An explicit short-`expire` public cache (e.g. `cacheLife({ expire: 0
++  // })`) keeps its life so it stays correctly excluded from static prerenders
++  // via its real `expire` while a reload still hits the cache; forcing
++  // `revalidate: 0` here would instead corrupt the cache life propagated to an
++  // enclosing cache and trigger the nested-dynamic error. A cache backed by a
++  // custom handler keeps its real cache life too, since that handler owns it.
+   const forceDynamicCacheLifeInDev = isPrivateCacheInDev
+ 
+   // If cacheLife() was used to set an explicit revalidate/expire/stale time we
+@@ -1640,7 +1645,7 @@ export async function cache(
+     if (isPrivate) {
+       // Private caches normally go to the Resume Data Cache (RDC), not a cache
+       // handler. In development we additionally persist them in a dedicated
+-      // built-in in-memory handler so that warm reloads are fast.
++      // built-in in-memory handler so that reloads are fast.
+       if (process.env.__NEXT_DEV_SERVER) {
+         cacheHandler = getPrivateCacheHandler()
+       }
+@@ -1652,7 +1657,7 @@ export async function cache(
+ 
+       // In development, a user-configured (custom) handler may be slow or
+       // remote, so we read through a tiered handler that puts a built-in
+-      // in-memory front in front of it to keep warm reads microtask-fast.
++      // in-memory front in front of it to keep cache hits microtask-fast.
+       // Built-in handlers (the default handler, and its size-0 replacement) are
+       // already in-memory and used directly.
+       if (process.env.__NEXT_DEV_SERVER && isCustomCacheHandler(kind)) {
+@@ -2188,7 +2193,7 @@ export async function cache(
+ 
+   let stream: undefined | ReadableStream = undefined
+ 
+-  // Set when a short-lived warm hit ends its cache read up front (dev only) so
++  // Set when a short-lived cache hit ends its cache read up front (dev only) so
+   // the static-shell boundary doesn't count it as a phantom miss. Once set, the
+   // cache signal read is balanced, so serving must use a plain stream and skip
+   // any trailing cacheSignal.endRead() call.
+@@ -2945,7 +2950,19 @@ export async function cache(
+ 
+         if (
+           entry === undefined ||
+-          currentTime > entry.timestamp + entry.expire * 1000 ||
++          // In dev, the built-in default handler retains a short-`expire` entry
++          // for at least `MIN_PRERENDERABLE_EXPIRE`, both when used directly
++          // and when fronting a custom cache handler. Apply that same minimum
++          // here so the retained entry is served and re-warmed in the
++          // background (below), rather than blocking to regenerate it on every
++          // read. The entry's real `expire` is untouched, so staging still
++          // treats it as dynamic.
++          currentTime >
++            entry.timestamp +
++              (process.env.__NEXT_DEV_SERVER
++                ? Math.max(entry.expire, MIN_PRERENDERABLE_EXPIRE)
++                : entry.expire) *
++                1000 ||
+           (workStore.isStaticGeneration &&
+             currentTime > entry.timestamp + entry.revalidate * 1000)
+         ) {
+@@ -3134,19 +3151,24 @@ export async function cache(
+ 
+           // Trigger a background revalidation when the entry is stale (past its
+           // `revalidate`), so the next read gets a fresh value without blocking
+-          // this one. In development with the in-memory cache disabled
+-          // (`cacheMaxMemorySize: 0`), built-in entries keep their resolved
+-          // (potentially non-dynamic) cache life, so an entry read back from
+-          // the dev in-memory cache is normally still fresh and wouldn't
+-          // revalidate on its own; revalidate those on every dynamic request
+-          // render too, so each reload still shows a fresh value.
++          // this one. Development additionally re-warms on every dynamic
++          // request render in two cases where the dev in-memory entry would
++          // otherwise read back as fresh, so a subsequent reload still shows a
++          // fresh value. The first is with the in-memory cache disabled
++          // (`cacheMaxMemorySize: 0`), where built-in entries keep their
++          // resolved (potentially non-dynamic) cache life. The second is a
++          // short-`expire` entry (an explicit dynamic or client-only cache,
++          // e.g. `cacheLife({ expire: 0 })`), which is retained for at least
++          // `MIN_PRERENDERABLE_EXPIRE` so it is served from the cache; this
++          // also covers custom handlers, re-executing and writing through to
++          // the backing.
+           let shouldTriggerBackgroundRevalidation =
+             currentTime > entry.timestamp + entry.revalidate * 1000
+           if (
+             !shouldTriggerBackgroundRevalidation &&
+             process.env.__NEXT_DEV_SERVER &&
+-            isMemoryCacheDisabled() &&
+-            !isCustomCacheHandler(kind)
++            (entry.expire < MIN_PRERENDERABLE_EXPIRE ||
++              (isMemoryCacheDisabled() && !isCustomCacheHandler(kind)))
+           ) {
+             switch (workUnitStore.type) {
+               case 'request':

nextjs-cache-short-expire-dev/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch

nextjs-cache-short-expire-dev/tests/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && pnpm install --frozen-lockfile && ANALYZE=1 pnpm build && pnpm exec playwright install --with-deps chromium' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app

nextjs-cache-short-expire-dev/tests/test.patch

@@ -0,0 +1,246 @@
+diff --git a/test/development/app-dir/cache-components-dev-streaming/app/page.tsx b/test/development/app-dir/cache-components-dev-streaming/app/page.tsx
+index a5d1524c73..4f3c15dfb9 100644
+--- a/test/development/app-dir/cache-components-dev-streaming/app/page.tsx
++++ b/test/development/app-dir/cache-components-dev-streaming/app/page.tsx
+@@ -14,6 +14,11 @@ export default function Page() {
+           /use-cache-private-runtime-prefetch
+         </Link>
+       </li>
++      <li>
++        <Link href="/use-cache-expire-zero/nav">
++          /use-cache-expire-zero/nav
++        </Link>
++      </li>
+       <li>
+         <Link href="/partial-prefetching/session-data">
+           /partial-prefetching/session-data
+diff --git a/test/development/app-dir/cache-components-dev-streaming/app/use-cache-expire-zero/[slug]/page.tsx b/test/development/app-dir/cache-components-dev-streaming/app/use-cache-expire-zero/[slug]/page.tsx
+new file mode 100644
+index 0000000000..cdf45502d4
+--- /dev/null
++++ b/test/development/app-dir/cache-components-dev-streaming/app/use-cache-expire-zero/[slug]/page.tsx
+@@ -0,0 +1,43 @@
++import { Suspense } from 'react'
++import { setTimeout } from 'timers/promises'
++import { cacheLife } from 'next/cache'
++
++export const prefetch = 'allow-runtime'
++
++// A distinct slug per test keys a separate cache entry (so the first request
++// for each slug is a genuine cold miss), while both tests share this one
++// runtime-prefetchable page. Declaring the slugs also keeps `params` statically
++// known, so the page shell doesn't depend on dynamic params. In development
++// this does not pre-fill the cache.
++export function generateStaticParams() {
++  return [{ slug: 'nav' }, { slug: 'reload' }]
++}
++
++async function getExpireZeroValue(slug: string) {
++  'use cache'
++  // An explicit short `expire` opts this public cache into a dynamic,
++  // client-only life: excluded from the static shell, but included in the
++  // runtime prefetch. The slug keys the entry; the value itself is just a
++  // timestamp.
++  cacheLife({ expire: 0 })
++  await setTimeout(1500)
++  return new Date().toISOString()
++}
++
++async function ExpireZeroCached({ slug }: Promise<{ slug: string }>) {
++  const value = await getExpireZeroValue(slug)
++
++  return <p id="expire-zero">{value}</p>
++}
++
++export default function Page({
++  params,
++}: {
++  params: Promise<{ slug: string }>
++}) {
++  return (
++    <Suspense fallback={<p id="expire-zero-fallback">Loading...</p>}>
++      <ExpireZeroCached slug={params.then(({ slug }) => slug)} />
++    </Suspense>
++  )
++}
+diff --git a/test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts b/test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts
+index 2f649898b1..b8c3b0eb1a 100644
+--- a/test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts
++++ b/test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts
+@@ -189,6 +189,91 @@ describe('cache-components-dev-streaming', () => {
+     })
+   })
+ 
++  it('shows the short-expire-cache fallback on a cold client navigation but not on a warm one', async () => {
++    // A public `'use cache'` with an explicit short `expire` (`cacheLife({
++    // expire: 0 })`) is a runtime-prefetch route here, so its cached content
++    // belongs to the runtime shell stage. On a warm navigation the dev minimum
++    // retention keeps the entry available, and the client defers revealing the
++    // response until the shell has flushed, so the content arrives with the
++    // shell and the fallback isn't shown - just like a private cache.
++    const browser = await next.browser('/')
++
++    // Cold navigation: the cache misses and fills in the background, so the
++    // fallback is shown until the content streams in.
++    await browser.elementByCss('a[href="/use-cache-expire-zero/nav"]').click()
++    expect(await browser.elementByCss('#expire-zero-fallback').text()).toBe(
++      'Loading...'
++    )
++    expect(await browser.elementByCss('#expire-zero').text()).toBeDateString()
++
++    // Wait for the background write to settle so the next navigation hits the
++    // warm entry instead of racing a pending write.
++    await waitFor(2000)
++
++    // Hard-reload home so the warm navigation below starts from a fresh page.
++    await browser.loadPage(new URL('/', next.url).href)
++
++    // Warm navigation: record whether the fallback ever enters the DOM. It
++    // shouldn't, since the retained entry is delivered with the shell. (The
++    // client-side reveal race that this delivery relies on is covered by the
++    // private-cache test above, so we don't repeat its stress loop here.)
++    const fallbackObserver = observeNodeAppearances(browser, [
++      'expire-zero-fallback',
++    ])
++
++    await fallbackObserver.observe()
++
++    await browser.elementByCss('a[href="/use-cache-expire-zero/nav"]').click()
++    expect(await browser.elementByCss('#expire-zero').text()).toBeDateString()
++
++    const appearanceCounts = await fallbackObserver.getResult()
++    expect(appearanceCounts).toEqual({
++      'expire-zero-fallback': 0,
++    })
++  })
++
++  it('serves a short-expire cache warm on reload and converges to a fresh value', async () => {
++    const browser = await next.browser('/use-cache-expire-zero/reload', {
++      waitHydration: false,
++      // Do not wait for "load"; inspect the page as it streams in.
++      waitUntil: 'commit',
++    })
++
++    // Cold load: the cache misses, so the fallback streams first, and the
++    // generated value streams in once generation completes. The value is a
++    // dynamic hole (real `expire: 0`), so it streams in after the shell.
++    expect(
++      await browser
++        .elementByCss('#expire-zero-fallback', { waitUntil: false })
++        .text()
++    ).toBe('Loading...')
++    const coldValue = await browser
++      .elementByCss('#expire-zero', { waitUntil: false })
++      .text()
++    expect(coldValue).toBeDateString()
++
++    // Warm reload: the dev minimum retention keeps the short-expire entry, so
++    // the reload serves the previously cached value fast instead of
++    // regenerating it. A background revalidation regenerates a fresh entry for
++    // the next reload (asserted below). We wait for the streamed-in element
++    // without waiting for "load", so no retry is needed.
++    await browser.refresh({ waitUntil: 'commit' })
++    expect(
++      await browser.elementByCss('#expire-zero', { waitUntil: false }).text()
++    ).toBe(coldValue)
++
++    // That warm reload re-warmed a fresh entry in the background, so a later
++    // reload converges to the new value. Read after "load" here (a plain
++    // refresh) since we want the settled value, not the streaming inspection
++    // above.
++    await retry(async () => {
++      await browser.refresh()
++      expect(await browser.elementById('expire-zero').text()).not.toBe(
++        coldValue
++      )
++    })
++  })
++
+   // The following are smoke tests that Cache Components validation still
+   // surfaces errors for both cold-cache renders (validated via a separate
+   // warm-cache render) and warm-cache renders (validated via the streamed
+diff --git a/test/development/app-dir/use-cache-custom-handler-dev/app/expire-zero/page.tsx b/test/development/app-dir/use-cache-custom-handler-dev/app/expire-zero/page.tsx
+new file mode 100644
+index 0000000000..e7d5b06820
+--- /dev/null
++++ b/test/development/app-dir/use-cache-custom-handler-dev/app/expire-zero/page.tsx
+@@ -0,0 +1,36 @@
++import { Suspense } from 'react'
++import { setTimeout } from 'timers/promises'
++import { cacheLife } from 'next/cache'
++
++// A public `'use cache'` routed through the custom (slow) handler, with an
++// explicit short `expire`. In dev the built-in front handler applies a minimum
++// retention, so a cache hit still resolves from the front in a microtask
++// instead of paying the backing's latency on every read.
++async function getCachedValue() {
++  'use cache'
++  // `expire: 0` gives a short, dynamic (client-only) cache life, excluded from
++  // static prerenders. Reusing it across client navigations would require
++  // opting the route into runtime prefetching (`prefetch = 'allow-runtime'`) so
++  // Cached Navigations embeds it into the client router cache; this fixture
++  // doesn't, since the test only exercises the dev front handler serving it
++  // warm on reloads.
++  cacheLife({ expire: 0 })
++  await setTimeout(1000)
++  return new Date().toISOString()
++}
++
++async function CachedValue() {
++  const value = await getCachedValue()
++
++  return <p id="value">{value}</p>
++}
++
++export default function Page() {
++  return (
++    <main>
++      <Suspense fallback={<p id="loading">Loading...</p>}>
++        <CachedValue />
++      </Suspense>
++    </main>
++  )
++}
+diff --git a/test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts b/test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts
+index f7a8508129..197060fa4a 100644
+--- a/test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts
++++ b/test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts
+@@ -40,6 +40,38 @@ describe('use-cache-custom-handler-dev', () => {
+     expect(await browser.hasElementByCss('[data-cold-cache-badge]')).toBe(false)
+   })
+ 
++  it('serves a short-expire value warm through a custom handler and re-warms it on each reload', async () => {
++    const browser = await next.browser('/expire-zero', {
++      waitHydration: false,
++      // Do not wait for "load"; inspect the page as it streams in.
++      waitUntil: 'commit',
++    })
++
++    // Cold load: the custom handler misses, the value generates and is written
++    // through to both the backing handler and the dev-only in-memory front. We
++    // wait for the streamed-in element without waiting for "load".
++    const coldValue = await browser
++      .elementByCss('#value', { waitUntil: false })
++      .text()
++    expect(coldValue).toBeDateString()
++
++    // Warm reload: served fast from the front, whose minimum retention keeps
++    // the short-`expire` entry. The custom handler's slow `get` isn't on the
++    // critical path, and the short `expire` no longer evicts the front entry on
++    // every read, so the same cached value shows.
++    await browser.refresh({ waitUntil: 'commit' })
++    expect(
++      await browser.elementByCss('#value', { waitUntil: false }).text()
++    ).toBe(coldValue)
++
++    // Each warm reload re-executes the cache function and writes through to the
++    // backing, so reloads converge to a fresh value.
++    await retry(async () => {
++      await browser.refresh()
++      expect(await browser.elementById('value').text()).not.toBe(coldValue)
++    })
++  })
++
+   it('stops serving a front-cached entry after the backing cache is purged out-of-band', async () => {
+     const browser = await next.browser('/purged')
+ 

nextjs-cache-short-expire-dev/tests/test.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts' --exclude='test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts/*' --exclude='test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts' --exclude='test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  git -C /app restore --source=HEAD --staged --worktree -- 'test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts' 'test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts' 'test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts' >/dev/null 2>&1 || true
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts' '/app/test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'ANALYZE=1 pnpm build && pnpm test-dev '"'"'test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts'"'"' '"'"'test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'ANALYZE=1 pnpm build && pnpm test-dev '"'"'test/development/app-dir/cache-components-dev-streaming/cache-components-dev-streaming.test.ts'"'"' '"'"'test/development/app-dir/use-cache-custom-handler-dev/use-cache-custom-handler-dev.test.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'ANALYZE=1 pnpm build && pnpm test-dev '"'"'test/development/app-dir/use-cache-size-zero/use-cache-size-zero.test.ts'"'"' '"'"'test/development/app-dir/basic/basic.test.ts'"'"''; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0

nextjs-cna-tailwind-turbopack/environment/Dockerfile

@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && NEXT_SKIP_NATIVE_POSTINSTALL=0 pnpm install --frozen-lockfile && pnpm exec playwright install --with-deps chromium && pnpm turbo run build --filter=next --filter=create-next-app --filter=eslint-config-next --log-order=stream && pnpm turbo run pack-for-isolated-tests --filter=next --filter=eslint-config-next --log-order=stream' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app

nextjs-cna-tailwind-turbopack/solution/gold.patch

@@ -0,0 +1,61 @@
+diff --git a/packages/create-next-app/templates/index.ts b/packages/create-next-app/templates/index.ts
+index cd3221494140802f61b6ea0cdd8f8958b3a1b543..7810b69c707dfbe33a170dfaec06aaeefe614a23 100644
+--- a/packages/create-next-app/templates/index.ts
++++ b/packages/create-next-app/templates/index.ts
+@@ -72,7 +72,9 @@ export const installTemplate = async ({
+   const copySource = ["**"];
+   if (!eslint) copySource.push("!eslint.config.mjs");
+   if (!biome) copySource.push("!biome.json");
+-  if (!tailwind) copySource.push("!postcss.config.mjs");
++  if (!tailwind || bundler === Bundler.Turbopack) {
++    copySource.push("!postcss.config.mjs");
++  }
+ 
+   await copy(copySource, root, {
+     parents: true,
+@@ -109,6 +111,30 @@ export const installTemplate = async ({
+     );
+   }
+ 
++  if (tailwind && bundler === Bundler.Turbopack) {
++    const nextConfigFile = path.join(
++      root,
++      mode === "js" ? "next.config.mjs" : "next.config.ts",
++    );
++    let configContent = await fs.readFile(nextConfigFile, "utf8");
++
++    configContent = configContent.replace(
++      "/* config options here */\n",
++      `/* config options here */
++  turbopack: {
++    rules: {
++      "*.css": {
++        loaders: ["@tailwindcss/turbopack"],
++        as: "*.css",
++      },
++    },
++  },
++`,
++    );
++
++    await fs.writeFile(nextConfigFile, configContent);
++  }
++
+   if (reactCompiler) {
+     const nextConfigFile = path.join(
+       root,
+@@ -278,9 +304,13 @@ export const installTemplate = async ({
+ 
+   /* Add Tailwind CSS dependencies. */
+   if (tailwind) {
++    const tailwindPlugin =
++      bundler === Bundler.Turbopack
++        ? "@tailwindcss/turbopack"
++        : "@tailwindcss/postcss";
+     packageJson.devDependencies = {
+       ...packageJson.devDependencies,
+-      "@tailwindcss/postcss": "^4",
++      [tailwindPlugin]: "^4",
+       tailwindcss: "^4",
+     };
+   }

nextjs-cna-tailwind-turbopack/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch

nextjs-cna-tailwind-turbopack/tests/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && NEXT_SKIP_NATIVE_POSTINSTALL=0 pnpm install --frozen-lockfile && pnpm exec playwright install --with-deps chromium && pnpm turbo run build --filter=next --filter=create-next-app --filter=eslint-config-next --log-order=stream && pnpm turbo run pack-for-isolated-tests --filter=next --filter=eslint-config-next --log-order=stream' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app

nextjs-cna-tailwind-turbopack/tests/test.patch

@@ -0,0 +1,342 @@
+diff --git a/test/production/create-next-app/lib/specification.ts b/test/production/create-next-app/lib/specification.ts
+index 20d75029..ed1f17ca 100644
+--- a/test/production/create-next-app/lib/specification.ts
++++ b/test/production/create-next-app/lib/specification.ts
+@@ -19,6 +19,12 @@ export type ProjectSpecification = {
+   }
+ }
+ 
++const tailwindFiles = process.env.NEXT_RSPACK ? ['postcss.config.mjs'] : []
++const tailwindDevDeps = [
++  process.env.NEXT_RSPACK ? '@tailwindcss/postcss' : '@tailwindcss/turbopack',
++  'tailwindcss',
++]
++
+ /**
+  * Required files for a given project template and mode.
+  */
+@@ -95,10 +101,10 @@ export const projectSpecification: ProjectSpecification = {
+         'pages/_app.js',
+         'pages/api/hello.js',
+         'pages/index.js',
+-        'postcss.config.mjs',
++        ...tailwindFiles,
+       ],
+       deps: [],
+-      devDeps: ['@tailwindcss/postcss', 'tailwindcss'],
++      devDeps: tailwindDevDeps,
+     },
+     ts: {
+       files: [
+@@ -106,7 +112,7 @@ export const projectSpecification: ProjectSpecification = {
+         'pages/_app.tsx',
+         'pages/api/hello.ts',
+         'pages/index.tsx',
+-        'postcss.config.mjs',
++        ...tailwindFiles,
+         'tsconfig.json',
+       ],
+       deps: [],
+@@ -114,8 +120,7 @@ export const projectSpecification: ProjectSpecification = {
+         '@types/node',
+         '@types/react-dom',
+         '@types/react',
+-        '@tailwindcss/postcss',
+-        'tailwindcss',
++        ...tailwindDevDeps,
+         'typescript',
+       ],
+     },
+@@ -126,17 +131,17 @@ export const projectSpecification: ProjectSpecification = {
+         'jsconfig.json',
+         'pages/_app.js',
+         'pages/index.js',
+-        'postcss.config.mjs',
++        ...tailwindFiles,
+       ],
+       deps: [],
+-      devDeps: ['@tailwindcss/postcss', 'tailwindcss'],
++      devDeps: tailwindDevDeps,
+     },
+     ts: {
+       files: [
+         'next-env.d.ts',
+         'pages/_app.tsx',
+         'pages/index.tsx',
+-        'postcss.config.mjs',
++        ...tailwindFiles,
+         'tsconfig.json',
+       ],
+       deps: [],
+@@ -144,8 +149,7 @@ export const projectSpecification: ProjectSpecification = {
+         '@types/node',
+         '@types/react-dom',
+         '@types/react',
+-        '@tailwindcss/postcss',
+-        'tailwindcss',
++        ...tailwindDevDeps,
+         'typescript',
+       ],
+     },
+@@ -214,12 +218,12 @@ export const projectSpecification: ProjectSpecification = {
+   'app-tw': {
+     js: {
+       deps: [],
+-      devDeps: ['@tailwindcss/postcss', 'tailwindcss'],
++      devDeps: tailwindDevDeps,
+       files: [
+         'app/layout.js',
+         'app/page.js',
+         'jsconfig.json',
+-        'postcss.config.mjs',
++        ...tailwindFiles,
+       ],
+     },
+     ts: {
+@@ -228,15 +232,14 @@ export const projectSpecification: ProjectSpecification = {
+         '@types/node',
+         '@types/react-dom',
+         '@types/react',
+-        '@tailwindcss/postcss',
+-        'tailwindcss',
++        ...tailwindDevDeps,
+         'typescript',
+       ],
+       files: [
+         'app/layout.tsx',
+         'app/page.tsx',
+         'next-env.d.ts',
+-        'postcss.config.mjs',
++        ...tailwindFiles,
+         'tsconfig.json',
+       ],
+     },
+@@ -244,12 +247,12 @@ export const projectSpecification: ProjectSpecification = {
+   'app-tw-empty': {
+     js: {
+       deps: [],
+-      devDeps: ['@tailwindcss/postcss', 'tailwindcss'],
++      devDeps: tailwindDevDeps,
+       files: [
+         'app/layout.js',
+         'app/page.js',
+         'jsconfig.json',
+-        'postcss.config.mjs',
++        ...tailwindFiles,
+       ],
+     },
+     ts: {
+@@ -258,15 +261,14 @@ export const projectSpecification: ProjectSpecification = {
+         '@types/node',
+         '@types/react-dom',
+         '@types/react',
+-        '@tailwindcss/postcss',
+-        'tailwindcss',
++        ...tailwindDevDeps,
+         'typescript',
+       ],
+       files: [
+         'app/layout.tsx',
+         'app/page.tsx',
+         'next-env.d.ts',
+-        'postcss.config.mjs',
++        ...tailwindFiles,
+         'tsconfig.json',
+       ],
+     },
+diff --git a/test/production/create-next-app/lib/utils.ts b/test/production/create-next-app/lib/utils.ts
+index 4787efbc..9e0da8d2 100644
+--- a/test/production/create-next-app/lib/utils.ts
++++ b/test/production/create-next-app/lib/utils.ts
+@@ -143,18 +143,21 @@ export const shouldBeTemplateProject = ({
+   mode,
+   srcDir,
+ }: CustomTemplateOptions) => {
++  const isTailwindTemplate = [
++    'app-tw',
++    'app-tw-empty',
++    'default-tw',
++    'default-tw-empty',
++  ].includes(template)
++
+   projectFilesShouldExist({
+     cwd,
+     projectName,
+     files: getProjectSetting({ template, mode, setting: 'files', srcDir }),
+   })
+ 
+-  // Tailwind templates share the same files (tailwind.config.mjs, postcss.config.mjs)
+-  if (
+-    !['app-tw', 'app-tw-empty', 'default-tw', 'default-tw-empty'].includes(
+-      template
+-    )
+-  ) {
++  // Tailwind templates share the same files across JavaScript and TypeScript.
++  if (!isTailwindTemplate) {
+     projectFilesShouldNotExist({
+       cwd,
+       projectName,
+@@ -165,6 +168,14 @@ export const shouldBeTemplateProject = ({
+     })
+   }
+ 
++  if (isTailwindTemplate && !process.env.NEXT_RSPACK) {
++    projectFilesShouldNotExist({
++      cwd,
++      projectName,
++      files: ['postcss.config.mjs'],
++    })
++  }
++
+   projectDepsShouldBe({
+     type: 'dependencies',
+     cwd,
+diff --git a/test/production/create-next-app/templates/app.test.ts b/test/production/create-next-app/templates/app.test.ts
+index f52d05fa..9593db13 100644
+--- a/test/production/create-next-app/templates/app.test.ts
++++ b/test/production/create-next-app/templates/app.test.ts
+@@ -1,4 +1,7 @@
++import { readFileSync } from 'fs'
++import { join } from 'path'
+ import {
++  projectFilesShouldExist,
+   projectShouldHaveNoGitChanges,
+   resolveNextTgzFilename,
+   shouldBeTemplateProject,
+@@ -145,7 +148,49 @@ describe('create-next-app --app (App Router)', () => {
+       await tryNextDev({
+         cwd,
+         projectName,
++        tailwind: true,
+       })
++
++      // The non-Turbopack path must keep its PostCSS integration.
++      if (!process.env.NEXT_RSPACK) {
++        const rspackProjectName = 'app-tw-rspack'
++        const rspackResult = await run(
++          [
++            rspackProjectName,
++            '--ts',
++            '--app',
++            '--tailwind',
++            '--rspack',
++            '--skip-install',
++            '--no-eslint',
++            '--no-biome',
++            '--no-src-dir',
++            '--no-import-alias',
++            '--no-react-compiler',
++            '--no-agents-md',
++          ],
++          nextTgzFilename,
++          { cwd }
++        )
++
++        expect(rspackResult.exitCode).toBe(0)
++        projectFilesShouldExist({
++          cwd,
++          projectName: rspackProjectName,
++          files: ['postcss.config.mjs'],
++        })
++        const rspackRoot = join(cwd, rspackProjectName)
++        const rspackPackage = JSON.parse(
++          readFileSync(join(rspackRoot, 'package.json'), 'utf8')
++        )
++        expect(rspackPackage.devDependencies).toHaveProperty(
++          '@tailwindcss/postcss'
++        )
++        expect(rspackPackage.devDependencies).toHaveProperty('tailwindcss')
++        expect(rspackPackage.devDependencies).not.toHaveProperty(
++          '@tailwindcss/turbopack'
++        )
++      }
+     })
+   })
+ 
+diff --git a/test/production/create-next-app/utils.ts b/test/production/create-next-app/utils.ts
+index 73a46770..39411d8a 100644
+--- a/test/production/create-next-app/utils.ts
++++ b/test/production/create-next-app/utils.ts
+@@ -2,6 +2,7 @@ import execa from 'execa'
+ import { join } from 'path'
+ import { spawn } from 'child_process'
+ import { fetchViaHTTP, findPort, killApp } from 'next-test-utils'
++import webdriver from 'next-webdriver'
+ import {
+   resolveTestPkgPaths,
+   serializeTestPkgPathsEnv,
+@@ -9,6 +10,15 @@ import {
+ 
+ export const CNA_PATH = require.resolve('create-next-app/dist/index.js')
+ 
++// Run create-next-app from TypeScript source so the test exercises the current
++// checkout. The verifier applies candidate changes after its build fixtures are
++// prepared, so invoking dist/index.js here would test a stale pre-patch bundle.
++const CNA_SOURCE_PATH = join(
++  __dirname,
++  '../../../packages/create-next-app/index.ts'
++)
++const TSX_CLI_PATH = require.resolve('tsx/cli')
++
+ /**
+  * Resolves the path to the packed `next` tarball. Uses NEXT_TEST_PKG_PATHS
+  * when available (set by run-tests.js), otherwise finds packed.tgz files
+@@ -49,7 +59,7 @@ export const run = async (
+         env?: Record<string, string>
+       }
+ ) => {
+-  return execa('node', [CNA_PATH].concat(args), {
++  return execa('node', [TSX_CLI_PATH, CNA_SOURCE_PATH].concat(args), {
+     // tests with options.reject false are expected to exit(1) so don't inherit
+     stdio: options.reject === false ? 'pipe' : 'inherit',
+     ...options,
+@@ -84,12 +94,14 @@ export async function tryNextDev({
+   isApp = true,
+   isApi = false,
+   isEmpty = false,
++  tailwind = false,
+ }: {
+   cwd: string
+   projectName: string
+   isApp?: boolean
+   isApi?: boolean
+   isEmpty?: boolean
++  tailwind?: boolean
+ }) {
+   // The caller wraps this in `useTempDir`, so `cwd` (and the CNA project
+   // inside it) is already an isolated temp directory that gets removed
+@@ -129,6 +141,8 @@ export async function tryNextDev({
+   // headroom so these tests aren't flaky on loaded CI machines.
+   const startServerTimeout = 60_000
+ 
++  let browser: Awaited<ReturnType<typeof webdriver>> | undefined
++
+   try {
+     await new Promise<void>((resolve, reject) => {
+       const onTimeout = setTimeout(() => {
+@@ -164,6 +178,17 @@ export async function tryNextDev({
+       })
+     })
+ 
++    // The webpack test matrix forces generated apps to build with webpack,
++    // but create-next-app only exposes Turbopack and Rspack as bundler choices.
++    // Only assert rendered Tailwind styles when the generated bundler matches
++    // the test bundler.
++    if (tailwind && !process.env.IS_WEBPACK_TEST) {
++      browser = await webdriver(port, '/')
++      expect(await browser.elementByCss('main').getComputedCss('display')).toBe(
++        'flex'
++      )
++    }
++
+     const res = await fetchViaHTTP(port, '/')
+     if (isEmpty || isApi) {
+       expect(await res.text()).toContain('Hello world!')
+@@ -190,6 +215,7 @@ export async function tryNextDev({
+       expect(apiRes.status).toBe(200)
+     }
+   } finally {
++    await browser?.close()
+     await killApp(server).catch(() => {})
+   }
+ }