Add files using upload-large-folder tool

nextjs-95375-instant-cookie-recovery/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-95375-instant-cookie-recovery/solution/gold.patch

@@ -0,0 +1,175 @@
+diff --git a/packages/next-playwright/src/index.ts b/packages/next-playwright/src/index.ts
+index 0267a1a716..291afa9ef0 100644
+--- a/packages/next-playwright/src/index.ts
++++ b/packages/next-playwright/src/index.ts
+@@ -29,6 +29,23 @@ interface PlaywrightPage {
+ 
+ const INSTANT_COOKIE = 'next-instant-navigation-testing'
+ 
++// Browser contexts that currently have an instant() scope executing. The
++// instant cookie is scoped to the browser context, so the context is the
++// natural granularity for the scope: two concurrent instant() calls on the same
++// context share one cookie and genuinely conflict, whereas calls on different
++// contexts (or different browsers) are independent and must not. Keying on the
++// context object preserves that isolation while giving a race-free nesting
++// signal.
++//
++// We track this in-process rather than inferring nesting from the cookie's
++// presence: a locked page asynchronously re-writes the instant cookie on every
++// MPA load (see navigation-testing-lock.ts), and that write can land right
++// after a prior scope's release deletes it, resurrecting the cookie once the
++// scope has already ended. Treating such a leftover as an active scope would
++// turn a benign residue into a cascading failure across every later test that
++// shares the browser context.
++const contextsWithActiveScope = new WeakSet<PlaywrightBrowserContext>()
++
+ /**
+  * Runs a function with instant navigation enabled. Within this scope,
+  * navigations render the prefetched UI immediately and wait for the
+@@ -55,10 +72,8 @@ export async function instant<T>(
+   fn: () => Promise<T>,
+   options?: { baseURL?: string }
+ ): Promise<T> {
+-  // Check for nested instant() calls. The cookie is scoped to the browser
+-  // context, so we can detect nesting by checking if it's already set.
+-  const existingCookies = await page.context().cookies()
+-  if (existingCookies.some((c) => c.name === INSTANT_COOKIE)) {
++  const context = page.context()
++  if (contextsWithActiveScope.has(context)) {
+     throw new Error(
+       'An instant() scope is already active. Nesting instant() ' +
+         'calls is not supported. Did you forget to await the ' +
+@@ -66,56 +81,86 @@ export async function instant<T>(
+     )
+   }
+ 
+-  // Acquire the lock by setting the cookie via the browser context. This
+-  // ensures the cookie is present even on the very first navigation.
+-  // The cookie triggers the CookieStore change event in
+-  // navigation-testing-lock.ts, which acquires the in-memory navigation lock.
++  // Resolve the cookie's scope before touching any browser state, so misuse on
++  // a fresh page (no baseURL and no prior navigation) fails with the
++  // descriptive error from resolveURL rather than half-entering a scope.
+   const { hostname } = new URL(resolveURL(page, options))
+-  await step('Acquire Instant Lock', () =>
+-    page.context().addCookies([
+-      {
+-        name: INSTANT_COOKIE,
+-        value: JSON.stringify([0, `p${Math.random()}`]),
+-        domain: hostname,
+-        path: '/',
+-      },
+-    ])
+-  )
++
++  contextsWithActiveScope.add(context)
+   try {
+-    return await fn()
++    // A completed prior scope on this context can leave the cookie behind (its
++    // client-side release races an in-flight captured-cookie write from a
++    // locked MPA page load; see the note above). No scope is active for this
++    // context, so a present cookie is always stale here — clear it before
++    // acquiring so a completed prior scope never blocks this one.
++    await releaseInstantCookie(context)
++
++    // Acquire the lock by setting the cookie via the browser context. This
++    // ensures the cookie is present even on the very first navigation. The
++    // cookie triggers the CookieStore change event in
++    // navigation-testing-lock.ts, which acquires the in-memory navigation lock.
++    await step('Acquire Instant Lock', () =>
++      context.addCookies([
++        {
++          name: INSTANT_COOKIE,
++          value: JSON.stringify([0, `p${Math.random()}`]),
++          domain: hostname,
++          path: '/',
++        },
++      ])
++    )
++    try {
++      return await fn()
++    } finally {
++      await step('Release Instant Lock', () => releaseInstantCookie(context))
++    }
+   } finally {
+-    // Release the lock by expiring the instant cookie, leaving every other
+-    // cookie untouched.
+-    //
+-    // We must NOT use `context.clearCookies({ name: INSTANT_COOKIE })` here.
+-    // Playwright implements a filtered `clearCookies` by clearing the ENTIRE
+-    // cookie jar and then re-adding the cookies that don't match the filter.
+-    // That briefly removes the application's own cookies too. Next.js reacts
+-    // to the instant cookie's deletion by immediately re-rendering, and if
+-    // that render's request races the empty window it observes none of the
+-    // app's cookies (e.g. a navigated page renders as if no cookies were set).
+-    //
+-    // Instead we read the instant cookie's stored entries (Next.js may have
+-    // updated the value, e.g. from [0] to [1,null], but preserves the domain
+-    // and path) and re-add each with a past expiry, which deletes only those
+-    // entries without disturbing the rest of the jar.
+-    await step('Release Instant Lock', async () => {
+-      const instantCookies = (await page.context().cookies()).filter(
+-        (cookie) => cookie.name === INSTANT_COOKIE
+-      )
+-      if (instantCookies.length > 0) {
+-        await page.context().addCookies(
+-          instantCookies.map((cookie) => ({
+-            name: cookie.name,
+-            value: cookie.value,
+-            domain: cookie.domain,
+-            path: cookie.path,
+-            // A past expiry (Unix epoch seconds) deletes the cookie.
+-            expires: 1,
+-          }))
+-        )
+-      }
+-    })
++    contextsWithActiveScope.delete(context)
++  }
++}
++
++/**
++ * Deletes the instant cookie, leaving every other cookie untouched.
++ *
++ * We must NOT use `context.clearCookies({ name: INSTANT_COOKIE })` here.
++ * Playwright implements a filtered `clearCookies` by clearing the ENTIRE cookie
++ * jar and then re-adding the cookies that don't match the filter. That briefly
++ * removes the application's own cookies too. Next.js reacts to the instant
++ * cookie's deletion by immediately re-rendering, and if that render's request
++ * races the empty window it observes none of the app's cookies (e.g. a
++ * navigated page renders as if no cookies were set).
++ *
++ * Instead we read the instant cookie's stored entries (Next.js may have updated
++ * the value, e.g. from [0] to [1,null], but preserves the domain and path) and
++ * re-add each with a past expiry, which deletes only those entries without
++ * disturbing the rest of the jar.
++ *
++ * A locked MPA page load can asynchronously re-write (resurrect) the cookie
++ * just after we delete it: the client only stops writing once it observes the
++ * deletion, an event that races the pending write. We therefore re-read and
++ * re-delete until the cookie stays gone, bounded so a cookie that some other
++ * actor keeps re-setting can't loop forever.
++ */
++async function releaseInstantCookie(
++  context: PlaywrightBrowserContext
++): Promise<void> {
++  for (let attempt = 0; attempt < 5; attempt++) {
++    const instantCookies = (await context.cookies()).filter(
++      (cookie) => cookie.name === INSTANT_COOKIE
++    )
++    if (instantCookies.length === 0) {
++      return
++    }
++    await context.addCookies(
++      instantCookies.map((cookie) => ({
++        name: cookie.name,
++        value: cookie.value,
++        domain: cookie.domain,
++        path: cookie.path,
++        // A past expiry (Unix epoch seconds) deletes the cookie.
++        expires: 1,
++      }))
++    )
+   }
+ }
+ 

nextjs-95375-instant-cookie-recovery/solution/solve.sh

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

nextjs-95375-instant-cookie-recovery/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-95375-instant-cookie-recovery/tests/test.patch

@@ -0,0 +1,87 @@
+diff --git a/test/e2e/app-dir/instant-navigation-testing-api/instant-navigation-testing-api.test.ts b/test/e2e/app-dir/instant-navigation-testing-api/instant-navigation-testing-api.test.ts
+index 212d760f63..78f8bb2a1a 100644
+--- a/test/e2e/app-dir/instant-navigation-testing-api/instant-navigation-testing-api.test.ts
++++ b/test/e2e/app-dir/instant-navigation-testing-api/instant-navigation-testing-api.test.ts
+@@ -216,6 +216,82 @@ describe('instant-navigation-testing-api', () => {
+     })
+   })
+ 
++  it('recovers from a stale instant cookie left by a prior scope', async () => {
++    const page = await openPage(next, '/')
++
++    // Simulate a cookie leaked by a previous instant() scope. A locked MPA page
++    // load re-writes the cookie asynchronously and can resurrect it right after
++    // a prior scope's release deletes it, leaving a captured-state entry in the
++    // shared browser context. Because the context is reused across tests, a new
++    // instant() call must treat that residue as stale (clearing it) rather than
++    // reporting an active scope, or every following test would cascade-fail.
++    const { hostname } = new URL(next.url)
++    await page.context().addCookies([
++      {
++        name: 'next-instant-navigation-testing',
++        value: JSON.stringify([1, 'c-stale', null]),
++        domain: hostname,
++        path: '/',
++      },
++    ])
++
++    let ranCallback = false
++    await instant(page, async () => {
++      ranCallback = true
++      await page.click('#link-to-target')
++      const loadingShell = page.locator('[data-testid="loading-shell"]')
++      await loadingShell.waitFor({ state: 'visible' })
++    })
++    expect(ranCallback).toBe(true)
++
++    // After exiting the scope the cookie is gone again, so a normal navigation
++    // is not locked and dynamic content streams in.
++    const dynamicContent = page.locator('[data-testid="dynamic-content"]')
++    await dynamicContent.waitFor({ state: 'visible' })
++  })
++
++  it('allows concurrent instant scopes across separate browser contexts', async () => {
++    const page = await openPage(next, '/')
++
++    // A second, independent browser context. Its cookie jar and its page's
++    // navigation lock are separate from the first context's, so a concurrent
++    // instant() scope here must not be reported as already active against the
++    // first. This guards against tracking the active scope per-process instead
++    // of per-context.
++    const browser = page.context().browser()
++    if (!browser) {
++      throw new Error('Expected the page context to expose a browser instance')
++    }
++    const otherContext = await browser.newContext()
++    try {
++      const otherPage = await otherContext.newPage()
++      await otherPage.goto(next.url)
++
++      let ranFirst = false
++      let ranSecond = false
++      await Promise.all([
++        instant(page, async () => {
++          ranFirst = true
++          await page.click('#link-to-target')
++          await page
++            .locator('[data-testid="loading-shell"]')
++            .waitFor({ state: 'visible' })
++        }),
++        instant(otherPage, async () => {
++          ranSecond = true
++          await otherPage.click('#link-to-target')
++          await otherPage
++            .locator('[data-testid="loading-shell"]')
++            .waitFor({ state: 'visible' })
++        }),
++      ])
++      expect(ranFirst).toBe(true)
++      expect(ranSecond).toBe(true)
++    } finally {
++      await otherContext.close()
++    }
++  })
++
+   it('renders shell on page reload', async () => {
+     const page = await openPage(next, '/target-page')
+ 

nextjs-95375-instant-cookie-recovery/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/instant-navigation-testing-api/instant-navigation-testing-api.test.ts' --exclude='test/e2e/app-dir/instant-navigation-testing-api/instant-navigation-testing-api.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/instant-navigation-testing-api/instant-navigation-testing-api.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/e2e/app-dir/instant-navigation-testing-api/instant-navigation-testing-api.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/instant-navigation-testing-api/instant-navigation-testing-api.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 --filter @next/playwright build && pnpm test-dev-webpack '"'"'test/e2e/app-dir/instant-navigation-testing-api/instant-navigation-testing-api.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm --filter @next/playwright build && pnpm test-dev-webpack '"'"'test/e2e/app-dir/instant-navigation-testing-api/instant-navigation-testing-api.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-96250-turbopack-route-announcements/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-96250-turbopack-route-announcements/solution/gold.patch

@@ -0,0 +1,41 @@
+diff --git a/packages/next/src/server/dev/hot-reloader-turbopack.ts b/packages/next/src/server/dev/hot-reloader-turbopack.ts
+index 2aaf1e65fe..d0b5d7b8ef 100644
+--- a/packages/next/src/server/dev/hot-reloader-turbopack.ts
++++ b/packages/next/src/server/dev/hot-reloader-turbopack.ts
+@@ -789,6 +789,9 @@ export async function createHotReloaderTurbopack(
+   // 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
++  // Undefined until the first entrypoints emission. That one has nothing to
++  // compare against, so every route it lists would look added.
++  let previousRouteKeys: Set<string> | undefined
+ 
+   // HACK: Defer sending `building` messages. Turbopack emits a compile pass for every
+   // foreground-job cycle, including empty no-op recompiles scheduled by
+@@ -1041,18 +1044,14 @@ export async function createHotReloaderTurbopack(
+       }
+ 
+       const routes = entrypoints.routes
+-      const existingRoutes = [
+-        ...currentEntrypoints.app.keys(),
+-        ...currentEntrypoints.page.keys(),
+-      ]
+-      const newRoutes = [...routes.keys()]
+-
+-      const addedRoutes = newRoutes.filter(
+-        (route) =>
+-          !currentEntrypoints.app.has(route) &&
+-          !currentEntrypoints.page.has(route)
+-      )
+-      const removedRoutes = existingRoutes.filter((route) => !routes.has(route))
++      const prevRouteKeys = previousRouteKeys
++      const addedRoutes = prevRouteKeys
++        ? [...routes.keys()].filter((route) => !prevRouteKeys.has(route))
++        : []
++      const removedRoutes = prevRouteKeys
++        ? [...prevRouteKeys].filter((route) => !routes.has(route))
++        : []
++      previousRouteKeys = new Set(routes.keys())
+ 
+       await handleEntrypoints({
+         entrypoints: entrypoints as any,

nextjs-96250-turbopack-route-announcements/solution/solve.sh

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

nextjs-96250-turbopack-route-announcements/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-96250-turbopack-route-announcements/tests/test.patch

@@ -0,0 +1,189 @@
+diff --git a/test/development/app-dir/route-change-refetch/fixtures/app/app/counted/page.tsx b/test/development/app-dir/route-change-refetch/fixtures/app/app/counted/page.tsx
+new file mode 100644
+index 00000000..214d82c0
+--- /dev/null
++++ b/test/development/app-dir/route-change-refetch/fixtures/app/app/counted/page.tsx
+@@ -0,0 +1,3 @@
++export default function Page() {
++  return <p id="counted">counted</p>
++}
+diff --git a/test/development/app-dir/route-change-refetch/fixtures/app/app/existing/page.tsx b/test/development/app-dir/route-change-refetch/fixtures/app/app/existing/page.tsx
+new file mode 100644
+index 00000000..03b551f3
+--- /dev/null
++++ b/test/development/app-dir/route-change-refetch/fixtures/app/app/existing/page.tsx
+@@ -0,0 +1,3 @@
++export default function Page() {
++  return <p id="existing">existing</p>
++}
+diff --git a/test/development/app-dir/route-change-refetch/fixtures/app/app/layout.tsx b/test/development/app-dir/route-change-refetch/fixtures/app/app/layout.tsx
+new file mode 100644
+index 00000000..e7077399
+--- /dev/null
++++ b/test/development/app-dir/route-change-refetch/fixtures/app/app/layout.tsx
+@@ -0,0 +1,7 @@
++export default function Root({ children }: { children: React.ReactNode }) {
++  return (
++    <html>
++      <body>{children}</body>
++    </html>
++  )
++}
+diff --git a/test/development/app-dir/route-change-refetch/fixtures/app/app/page.tsx b/test/development/app-dir/route-change-refetch/fixtures/app/app/page.tsx
+new file mode 100644
+index 00000000..56c1adc4
+--- /dev/null
++++ b/test/development/app-dir/route-change-refetch/fixtures/app/app/page.tsx
+@@ -0,0 +1,3 @@
++export default function Page() {
++  return <p id="home">home</p>
++}
+diff --git a/test/development/app-dir/route-change-refetch/fixtures/app/app/posts/[id]/page.tsx b/test/development/app-dir/route-change-refetch/fixtures/app/app/posts/[id]/page.tsx
+new file mode 100644
+index 00000000..20fd68f1
+--- /dev/null
++++ b/test/development/app-dir/route-change-refetch/fixtures/app/app/posts/[id]/page.tsx
+@@ -0,0 +1,4 @@
++export default async function Page(props: { params: Promise<{ id: string }> }) {
++  const { id } = await props.params
++  return <p id="dynamic">dynamic {id}</p>
++}
+diff --git a/test/development/app-dir/route-change-refetch/fixtures/app/app/renamed-a/page.tsx b/test/development/app-dir/route-change-refetch/fixtures/app/app/renamed-a/page.tsx
+new file mode 100644
+index 00000000..4ebc2313
+--- /dev/null
++++ b/test/development/app-dir/route-change-refetch/fixtures/app/app/renamed-a/page.tsx
+@@ -0,0 +1,3 @@
++export default function Page() {
++  return <p id="renamed">renamed</p>
++}
+diff --git a/test/development/app-dir/route-change-refetch/route-change-refetch.test.ts b/test/development/app-dir/route-change-refetch/route-change-refetch.test.ts
+new file mode 100644
+index 00000000..2bb4715a
+--- /dev/null
++++ b/test/development/app-dir/route-change-refetch/route-change-refetch.test.ts
+@@ -0,0 +1,124 @@
++import { nextTestSetup } from 'e2e-utils'
++import { retry, waitFor } from 'next-test-utils'
++import type { Page } from 'playwright'
++import * as nodeFs from 'node:fs'
++import * as nodePath from 'node:path'
++
++type RouteAnnouncement = {
++  type: 'addedPage' | 'removedPage'
++  route: string
++}
++
++function recordRouteAnnouncements(announcements: RouteAnnouncement[]) {
++  return (page: Page) => {
++    page.on('websocket', (ws) => {
++      if (new URL(ws.url()).pathname !== '/_next/hmr') return
++      ws.on('framereceived', (frame) => {
++        const payload =
++          typeof frame.payload === 'string'
++            ? frame.payload
++            : frame.payload.toString('utf8')
++        let message: { type?: string; data?: unknown[] }
++        try {
++          message = JSON.parse(payload)
++        } catch {
++          return
++        }
++        const route = message.data?.[0]
++        if (
++          (message.type === 'addedPage' || message.type === 'removedPage') &&
++          typeof route === 'string'
++        ) {
++          announcements.push({ type: message.type, route })
++        }
++      })
++    })
++  }
++}
++
++describe('Turbopack route change announcements', () => {
++  const { next } = nextTestSetup({
++    files: nodePath.join(__dirname, 'fixtures/app'),
++  })
++
++  async function cleanupAddedPage() {
++    if (nodeFs.existsSync(nodePath.join(next.testDir, 'app/zz-added'))) {
++      await next.deleteFile('app/zz-added/page.tsx')
++      await retry(async () => {
++        expect((await next.fetch('/zz-added')).status).toBe(404)
++      }, 15_000)
++    }
++  }
++
++  it('announces only the newly added route under its route name', async () => {
++    const announcements: RouteAnnouncement[] = []
++    const browser = await next.browser('/existing', {
++      beforePageLoad: recordRouteAnnouncements(announcements),
++    })
++    expect(await browser.elementById('existing').text()).toBe('existing')
++
++    try {
++      // Connecting to an already-running app establishes the baseline. None of
++      // its routes are changes, so they must not be announced.
++      await waitFor(1000)
++      expect(announcements).toEqual([])
++
++      await next.patchFile(
++        'app/zz-added/page.tsx',
++        'export default function Page() { return <p>added</p> }'
++      )
++      await retry(async () => {
++        expect((await next.fetch('/zz-added')).status).toBe(200)
++      }, 15_000)
++      await retry(async () => {
++        expect(announcements).toEqual([
++          { type: 'addedPage', route: '/zz-added' },
++        ])
++      }, 15_000)
++      await waitFor(1000)
++      expect(announcements).toEqual([
++        { type: 'addedPage', route: '/zz-added' },
++      ])
++    } finally {
++      await cleanupAddedPage()
++      await browser.close()
++    }
++  })
++
++  it('announces only the removed route under its route name', async () => {
++    const announcements: RouteAnnouncement[] = []
++    const browser = await next.browser('/existing', {
++      beforePageLoad: recordRouteAnnouncements(announcements),
++    })
++    expect(await browser.elementById('existing').text()).toBe('existing')
++
++    try {
++      await waitFor(1000)
++      expect(announcements).toEqual([])
++
++      await next.renameFile('app/existing/page.tsx', 'app/existing/page.bak')
++      await retry(async () => {
++        expect((await next.fetch('/existing')).status).toBe(404)
++      }, 15_000)
++      await retry(async () => {
++        expect(announcements).toEqual([
++          { type: 'removedPage', route: '/existing' },
++        ])
++      }, 15_000)
++      await waitFor(1000)
++      expect(announcements).toEqual([
++        { type: 'removedPage', route: '/existing' },
++      ])
++    } finally {
++      if (
++        nodeFs.existsSync(nodePath.join(next.testDir, 'app/existing/page.bak'))
++      ) {
++        await next.renameFile('app/existing/page.bak', 'app/existing/page.tsx')
++        await retry(async () => {
++          expect((await next.fetch('/existing')).status).toBe(200)
++        }, 15_000)
++      }
++      await browser.close()
++    }
++  })
++})

nextjs-96250-turbopack-route-announcements/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/route-change-refetch/route-change-refetch.test.ts' --exclude='test/development/app-dir/route-change-refetch/route-change-refetch.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/route-change-refetch/route-change-refetch.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/development/app-dir/route-change-refetch/route-change-refetch.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/route-change-refetch/route-change-refetch.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 --filter next build && pnpm test-dev-turbo '"'"'test/development/app-dir/route-change-refetch/route-change-refetch.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm --filter next build && pnpm test-dev-turbo '"'"'test/development/app-dir/route-change-refetch/route-change-refetch.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-96390-not-found-adapter/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 && 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-96390-not-found-adapter/solution/gold.patch

@@ -0,0 +1,60 @@
+diff --git a/packages/next/src/build/adapter/build-complete.ts b/packages/next/src/build/adapter/build-complete.ts
+index 131605cac3..00b7db3879 100644
+--- a/packages/next/src/build/adapter/build-complete.ts
++++ b/packages/next/src/build/adapter/build-complete.ts
+@@ -1387,12 +1387,6 @@ export async function handleBuildComplete({
+         const isAppPage =
+           Boolean(appOutputMap[srcRoute]) || srcRoute === '/_not-found'
+ 
+-        // if we already have 404.html favor that instead of
+-        // _not-found prerender
+-        if (srcRoute === '/_not-found' && hasStatic404) {
+-          continue
+-        }
+-
+         const isNotFoundTrue = prerenderManifest.notFoundRoutes.includes(route)
+ 
+         let allowQuery: string[] | undefined
+@@ -1458,6 +1452,13 @@ export async function handleBuildComplete({
+ 
+         const meta = await getAppRouteMeta(route, isAppPage)
+ 
++        // If we already have a complete 404.html, favor that instead of the
++        // _not-found prerender. A route with postponed state only produced a
++        // shell, so preserve its prerender output in order to resume it.
++        if (srcRoute === '/_not-found' && hasStatic404 && !meta.postponed) {
++          continue
++        }
++
+         let htmlAllowQuery = allowQuery
+         let dataAllowQuery = allowQuery
+         const dataInitialHeaders: Record<string, string> = {}
+diff --git a/packages/next/src/build/index.ts b/packages/next/src/build/index.ts
+index da2f222113..b4e175cd34 100644
+--- a/packages/next/src/build/index.ts
++++ b/packages/next/src/build/index.ts
+@@ -2983,8 +2983,6 @@ export default async function build(
+         !hasPages500 && !hasNonStaticErrorPage && !customAppGetInitialProps
+ 
+       const combinedPages = [...staticPages, ...ssgPages]
+-      const isApp404Static = staticPaths.has(UNDERSCORE_NOT_FOUND_ROUTE_ENTRY)
+-      const hasStaticApp404 = hasApp404 && isApp404Static
+       const isAppGlobalErrorStatic = staticPaths.has(
+         UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY
+       )
+@@ -3960,7 +3958,14 @@ export default async function build(
+               })
+           }
+ 
+-          // If there's /not-found inside app, we prefer it over the pages 404
++          // If there's a fully static /not-found inside app, we prefer it over
++          // the pages 404. A partially prerendered not-found is only a shell,
++          // so it must remain associated with its resumable prerender output.
++          const hasStaticApp404 =
++            hasApp404 &&
++            staticPaths.has(UNDERSCORE_NOT_FOUND_ROUTE_ENTRY) &&
++            !pageInfos.get(UNDERSCORE_NOT_FOUND_ROUTE)?.hasPostponed
++
+           if (hasStaticApp404) {
+             await moveExportedAppNotFoundTo404()
+           } else {

nextjs-96390-not-found-adapter/solution/solve.sh

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

nextjs-96390-not-found-adapter/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 && 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-96390-not-found-adapter/tests/test.patch

@@ -0,0 +1,160 @@
+diff --git a/test/e2e/app-dir/not-found-non-document-dynamic/app/layout.tsx b/test/e2e/app-dir/not-found-non-document-dynamic/app/layout.tsx
+index c9606f1555..0b374ba091 100644
+--- a/test/e2e/app-dir/not-found-non-document-dynamic/app/layout.tsx
++++ b/test/e2e/app-dir/not-found-non-document-dynamic/app/layout.tsx
+@@ -3,7 +3,7 @@ import { connection } from 'next/server'
+ 
+ async function Dynamic() {
+   await connection()
+-  return null
++  return <p id="dynamic-layout">dynamic layout content</p>
+ }
+ 
+ export default function Root({ children }: { children: ReactNode }) {
+diff --git a/test/e2e/app-dir/not-found-non-document-dynamic/my-adapter.mjs b/test/e2e/app-dir/not-found-non-document-dynamic/my-adapter.mjs
+new file mode 100644
+index 0000000000..23c2d2f097
+--- /dev/null
++++ b/test/e2e/app-dir/not-found-non-document-dynamic/my-adapter.mjs
+@@ -0,0 +1,9 @@
++import fs from 'fs/promises'
++
++/** @type {import('next').NextAdapter} */
++export default {
++  name: 'not-found-non-document-dynamic',
++  async onBuildComplete(ctx) {
++    await fs.writeFile('build-complete.json', JSON.stringify(ctx, null, 2))
++  },
++}
+diff --git a/test/e2e/app-dir/not-found-non-document-dynamic/next.config.js b/test/e2e/app-dir/not-found-non-document-dynamic/next.config.js
+index 807126e4cf..d0451f0268 100644
+--- a/test/e2e/app-dir/not-found-non-document-dynamic/next.config.js
++++ b/test/e2e/app-dir/not-found-non-document-dynamic/next.config.js
+@@ -3,4 +3,8 @@
+  */
+ const nextConfig = {}
+ 
++if (!process.env.NEXT_ADAPTER_PATH) {
++  nextConfig.adapterPath = require.resolve('./my-adapter.mjs')
++}
++
+ module.exports = nextConfig
+diff --git a/test/e2e/app-dir/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts b/test/e2e/app-dir/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts
+index 4c5140fd77..b6a85b661c 100644
+--- a/test/e2e/app-dir/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts
++++ b/test/e2e/app-dir/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts
+@@ -1,4 +1,5 @@
+-import { isNextDeploy, nextTestSetup } from 'e2e-utils'
++import { isNextDeploy, isNextStart, nextTestSetup } from 'e2e-utils'
++import type { NextAdapter } from 'next'
+ 
+ describe('not-found-non-document-dynamic', () => {
+   const { next } = nextTestSetup({
+@@ -48,7 +49,9 @@ describe('not-found-non-document-dynamic', () => {
+     })
+     expect(res.status).toBe(404)
+     expect(res.headers.get('content-type')).toContain('text/html')
+-    expect(await res.text()).toContain('custom not found page')
++    const html = await res.text()
++    expect(html).toContain('custom not found page')
++    expect(html).toContain('dynamic layout content')
+   })
+ 
+   it('renders the not-found page for fetch requests to unknown paths', async () => {
+@@ -61,6 +64,49 @@ describe('not-found-non-document-dynamic', () => {
+     })
+     expect(res.status).toBe(404)
+     expect(res.headers.get('content-type')).toContain('text/html')
+-    expect(await res.text()).toContain('custom not found page')
++    const html = await res.text()
++    expect(html).toContain('custom not found page')
++    expect(html).toContain('dynamic layout content')
+   })
++
++  it('renders dynamic not-found content when selected by a rewrite', async () => {
++    const res = await next.fetch('/rewritten-not-found')
++    const html = await res.text()
++
++    expect(res.status).toBe(404)
++    expect(res.headers.get('content-type')).toContain('text/html')
++    expect(html).toContain('custom not found page')
++    expect(html).toContain('dynamic layout content')
++  })
++
++  if (isNextStart && process.env.__NEXT_CACHE_COMPONENTS) {
++    it('publishes the partial not-found shell as a resumable prerender', async () => {
++      expect(await next.hasFile('.next/server/pages/404.html')).toBe(false)
++
++      const { outputs }: Parameters<NextAdapter['onBuildComplete']>[0] =
++        await next.readJSON('build-complete.json')
++      const notFoundPrerender = outputs.prerenders.find(
++        (output) => output.pathname === '/_not-found'
++      )
++
++      expect(notFoundPrerender).toMatchObject({
++        route: '/_not-found',
++        routeType: 'page',
++        response: 'initial',
++        compute: 'resuming',
++        pprChain: {
++          headers: {
++            'next-resume': '1',
++          },
++        },
++        config: {
++          renderingMode: 'PARTIALLY_STATIC',
++        },
++        fallback: {
++          postponedState: expect.any(String),
++          initialStatus: 404,
++        },
++      })
++    })
++  }
+ })
+diff --git a/test/e2e/app-dir/not-found-non-document-dynamic/proxy.ts b/test/e2e/app-dir/not-found-non-document-dynamic/proxy.ts
+new file mode 100644
+index 0000000000..52c8d6880b
+--- /dev/null
++++ b/test/e2e/app-dir/not-found-non-document-dynamic/proxy.ts
+@@ -0,0 +1,9 @@
++import { NextRequest, NextResponse } from 'next/server'
++
++export function proxy(request: NextRequest) {
++  if (request.nextUrl.pathname === '/rewritten-not-found') {
++    return NextResponse.rewrite(new URL('/_not-found', request.url), {
++      status: 404,
++    })
++  }
++}
+diff --git a/test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.test.ts b/test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.test.ts
+index 2922744e8f..e9877dcd5a 100644
+--- a/test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.test.ts
++++ b/test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.test.ts
+@@ -228,6 +228,17 @@ describe('adapter-prerender-metadata', () => {
+     expect(staticPage.htmlSize).toBeGreaterThan(0)
+   })
+ 
++  it('uses 404.html for a fully static not-found', async () => {
++    const prerenders = await getPrerenders()
++
++    expect(
++      prerenders.find((output) => output.pathname === '/_not-found')
++    ).toBeUndefined()
++    expect(await next.readFile('.next/server/pages/404.html')).toContain(
++      'Not Found'
++    )
++  })
++
+   it('classifies an upgradable app template as fallback', async () => {
+     const prerenders = await getPrerenders()
+     const template = prerenders.find(
+diff --git a/test/production/app-dir/adapter-prerender-metadata/app/not-found.tsx b/test/production/app-dir/adapter-prerender-metadata/app/not-found.tsx
+new file mode 100644
+index 0000000000..9db9e67b29
+--- /dev/null
++++ b/test/production/app-dir/adapter-prerender-metadata/app/not-found.tsx
+@@ -0,0 +1,3 @@
++export default function NotFound() {
++  return <p>Not Found</p>
++}

nextjs-96390-not-found-adapter/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/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts' --exclude='test/e2e/app-dir/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts/*' --exclude='test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.test.ts' --exclude='test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.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/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts' 'test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/e2e/app-dir/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts' 'test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.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/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts' '/app/test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.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 && NEXT_TELEMETRY_DISABLED=1 pnpm test-start-experimental-turbo '"'"'test/e2e/app-dir/not-found-non-document-dynamic/not-found-non-document-dynamic.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm build && NEXT_TELEMETRY_DISABLED=1 pnpm test-start-experimental-turbo '"'"'test/e2e/app-dir/not-found-non-document-dynamic/not-found-non-document-dynamic.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 && NEXT_TELEMETRY_DISABLED=1 pnpm test-start-experimental-turbo '"'"'test/production/app-dir/adapter-prerender-metadata/adapter-prerender-metadata.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-exact-binary-fetch-cache-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 enable && corepack prepare pnpm@10.33.0 --activate && pnpm install --frozen-lockfile && 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-exact-binary-fetch-cache-keys/solution/gold.patch

@@ -0,0 +1,301 @@
+diff --git a/packages/next/errors.json b/packages/next/errors.json
+index 6cf757d5c2..bc70516553 100644
+--- a/packages/next/errors.json
++++ b/packages/next/errors.json
+@@ -1440,5 +1440,6 @@
+   "1439": "Route \"%s\": Next.js encountered URL data during prerendering or a navigation.\\n\\n\\`params\\` or \\`searchParams\\` accessed outside of \\`<Suspense>\\` may prevent the navigation from being instant, leading to a slower user experience.\\n\\nWays to fix this:\\n  - [stream] Provide a placeholder with \\`<Suspense fallback={...}>\\` around the data access\\n  - [block] Set \\`export const instant = false\\` to allow a blocking route\\n\\nLearn more: https://nextjs.org/docs/messages/instant-shell-url-data",
+   "1440": "Route \"%s\": Next.js encountered uncached data during prerendering.\\n\\n\\`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\\nWays to fix this:\\n  - [stream] Provide a placeholder with \\`<Suspense fallback={...}>\\` around the data access\\n  - [cache] Cache the data access with \\`\"use cache\"\\` (does not apply to \\`connection()\\`)\\n  - [block] Set \\`export const instant = false\\` to allow a blocking route\\n\\nLearn more: https://nextjs.org/docs/messages/blocking-prerender-dynamic",
+   "1441": "DevValidationScheduler requires at least one active validation",
+-  "1442": "The Server Reference ID did not match the expected format. Received %s.\\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action"
++  "1442": "The Server Reference ID did not match the expected format. Received %s.\\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action",
++  "1443": "Unsupported body type: %s"
+ }
+diff --git a/packages/next/src/server/lib/incremental-cache/index.ts b/packages/next/src/server/lib/incremental-cache/index.ts
+index 918f5583fb..31f100be25 100644
+--- a/packages/next/src/server/lib/incremental-cache/index.ts
++++ b/packages/next/src/server/lib/incremental-cache/index.ts
+@@ -55,6 +55,50 @@ export interface CacheHandlerValue {
+   value: IncrementalCacheValue | null
+ }
+ 
++function toHex(buffer: ArrayBufferView | ArrayBuffer): string {
++  // Hex-encode body bytes losslessly: decoding as UTF-8 would collapse
++  // distinct bytes (0xff/0xfe to U+FFFD) and collide; Buffer isn't on edge.
++  const bytes = isArrayBuffer(buffer)
++    ? new Uint8Array(buffer)
++    : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
++  let hex = ''
++  for (const byte of bytes) {
++    hex += byte.toString(16).padStart(2, '0')
++  }
++  return hex
++}
++
++type Body = NonNullable<RequestInit['body'] | Request['body']>
++
++// Duck typing to support Edge runtime
++// TODO: Switch to instanceof checks once Edge runtime is removed.
++
++function isArrayBuffer(
++  buffer: ArrayBuffer | ArrayBufferView
++): buffer is ArrayBuffer {
++  return !('buffer' in buffer)
++}
++
++function isBodyByteSequence(
++  body: Body
++): body is ArrayBufferView<ArrayBuffer> | ArrayBuffer {
++  return typeof body === 'object' && 'byteLength' in body
++}
++
++function isBodyReadableStream(body: Body): body is ReadableStream {
++  return typeof (body as any).getReader === 'function'
++}
++
++function isBodyFormDataOrURLSearchParams(
++  body: Body
++): body is FormData | URLSearchParams {
++  return typeof (body as any).keys === 'function'
++}
++
++function isBodyBlob(body: Body): body is Blob {
++  return typeof (body as any).arrayBuffer === 'function'
++}
++
+ export class CacheHandler {
+   // eslint-disable-next-line
+   constructor(_ctx: CacheHandlerContext) {}
+@@ -80,6 +124,21 @@ export class CacheHandler {
+   public resetRequestCache(): void {}
+ }
+ 
++async function hashString(cacheString: string): Promise<string> {
++  if (process.env.NEXT_RUNTIME === 'edge') {
++    const encoder = new TextEncoder()
++    const buffer = encoder.encode(cacheString)
++    return toHex(await crypto.subtle.digest('SHA-256', buffer))
++  } else {
++    const crypto = require('crypto') as typeof import('crypto')
++    return crypto.createHash('sha256').update(cacheString).digest('hex')
++  }
++}
++
++// this should be bumped anytime a fix is made to cache entries
++// that should bust the cache
++const MAIN_KEY_PREFIX = 'v4'
++
+ export class IncrementalCache implements IncrementalCacheType {
+   readonly dev?: boolean
+   readonly disableForTestmode?: boolean
+@@ -288,28 +347,34 @@ export class IncrementalCache implements IncrementalCacheType {
+     return this.cacheHandler?.revalidateTag(tags, durations)
+   }
+ 
++  async generateSimpleCacheKey(input: string): Promise<string> {
++    const cacheString = JSON.stringify([
++      MAIN_KEY_PREFIX,
++      this.fetchCacheKeyPrefix || '',
++      input,
++    ])
++
++    return hashString(cacheString)
++  }
++
+   // x-ref: https://github.com/facebook/react/blob/2655c9354d8e1c54ba888444220f63e836925caa/packages/react/src/ReactFetch.js#L23
+   async generateCacheKey(
+     url: string,
+     init: RequestInit | Request = {}
+   ): Promise<string> {
+-    // this should be bumped anytime a fix is made to cache entries
+-    // that should bust the cache
+-    const MAIN_KEY_PREFIX = 'v3'
+-
+     const bodyChunks: string[] = []
+ 
+     const encoder = new TextEncoder()
+-    const decoder = new TextDecoder()
+ 
+-    if (init.body) {
+-      // handle Uint8Array body
+-      if (init.body instanceof Uint8Array) {
+-        bodyChunks.push(decoder.decode(init.body))
+-        ;(init as any)._ogBody = init.body
+-      } // handle ReadableStream body
+-      else if (typeof (init.body as any).getReader === 'function') {
+-        const readableBody = init.body as ReadableStream<Uint8Array | string>
++    // Will be set implementing https://fetch.spec.whatwg.org/#concept-bodyinit-extract
++    let bodyType: string | null = null
++    const body = init.body
++    if (body) {
++      if (isBodyByteSequence(body)) {
++        bodyChunks.push(`bytes:${toHex(body)}`)
++        ;(init as any)._ogBody = body
++      } else if (isBodyReadableStream(body)) {
++        const readableBody = body
+ 
+         const chunks: Uint8Array[] = []
+ 
+@@ -317,20 +382,13 @@ export class IncrementalCache implements IncrementalCacheType {
+           await readableBody.pipeTo(
+             new WritableStream({
+               write(chunk) {
+-                if (typeof chunk === 'string') {
+-                  chunks.push(encoder.encode(chunk))
+-                  bodyChunks.push(chunk)
+-                } else {
+-                  chunks.push(chunk)
+-                  bodyChunks.push(decoder.decode(chunk, { stream: true }))
+-                }
++                chunks.push(
++                  typeof chunk === 'string' ? encoder.encode(chunk) : chunk
++                )
+               },
+             })
+           )
+ 
+-          // Flush the decoder.
+-          bodyChunks.push(decoder.decode())
+-
+           // Create a new buffer with all the chunks.
+           const length = chunks.reduce((total, arr) => total + arr.length, 0)
+           const arrayBuffer = new Uint8Array(length)
+@@ -342,46 +400,54 @@ export class IncrementalCache implements IncrementalCacheType {
+             offset += chunk.length
+           }
+ 
++          bodyChunks.push(`bytes:${toHex(arrayBuffer)}`)
+           ;(init as any)._ogBody = arrayBuffer
+         } catch (err) {
+           console.error('Problem reading body', err)
+         }
+-      } // handle FormData or URLSearchParams bodies
+-      else if (typeof (init.body as any).keys === 'function') {
+-        const formData = init.body as FormData
+-        ;(init as any)._ogBody = init.body
+-        for (const key of new Set([...formData.keys()])) {
+-          const values = formData.getAll(key)
+-          bodyChunks.push(
+-            `${key}=${(
+-              await Promise.all(
+-                values.map(async (val) => {
+-                  if (typeof val === 'string') {
+-                    return val
+-                  } else {
+-                    return await val.text()
+-                  }
+-                })
+-              )
+-            ).join(',')}`
+-          )
++      } else if (isBodyFormDataOrURLSearchParams(body)) {
++        bodyType =
++          String(body) === '[object FormData]'
++            ? // We don't need a boundary because we're not actually using this for a Content-Type header
++              'multipart/form-data; boundary='
++            : 'application/x-www-form-urlencoded;charset=UTF-8'
++        const iterable = body
++        ;(init as any)._ogBody = body
++        // Separate, tagged chunks so `["a","b"]` can't collide with `["a,b"]`.
++        for (const [key, val] of iterable.entries()) {
++          bodyChunks.push(`key:${key}`)
++          if (typeof val === 'string') {
++            bodyChunks.push(`str:${val}`)
++          } else {
++            bodyChunks.push(
++              'file',
++              val.name,
++              val.type,
++              `bytes:${toHex(await val.arrayBuffer())}`
++            )
++          }
+         }
+         // handle blob body
+-      } else if (typeof (init.body as any).arrayBuffer === 'function') {
+-        const blob = init.body as Blob
++      } else if (isBodyBlob(body)) {
++        const blob = body
+         const arrayBuffer = await blob.arrayBuffer()
+-        bodyChunks.push(await blob.text())
++        bodyChunks.push('blob', blob.type, `bytes:${toHex(arrayBuffer)}`)
+         ;(init as any)._ogBody = new Blob([arrayBuffer], { type: blob.type })
+-      } else if (typeof init.body === 'string') {
+-        bodyChunks.push(init.body)
+-        ;(init as any)._ogBody = init.body
++        bodyType = blob.type
++      } else if (typeof body === 'string') {
++        bodyChunks.push(`str:${body}`)
++        ;(init as any)._ogBody = body
++        bodyType = 'text/plain;charset=UTF-8'
++      } else {
++        body satisfies never
++        throw new Error(`Unsupported body type: ${typeof body}`)
+       }
+     }
+ 
+     const headers =
+       typeof (init.headers || {}).keys === 'function'
+         ? Object.fromEntries(init.headers as Headers)
+-        : Object.assign({}, init.headers)
++        : Object.assign({} as Record<string, string>, init.headers)
+ 
+     // w3c trace context headers can break request caching and deduplication
+     // so we remove them from the cache key
+@@ -393,6 +459,9 @@ export class IncrementalCache implements IncrementalCacheType {
+       this.fetchCacheKeyPrefix || '',
+       url,
+       init.method,
++      // Ensures default Content-Type is part of the cache key
++      // TODO: Only necessary when headers are not used from the Request instance
++      bodyType,
+       headers,
+       init.mode,
+       init.redirect,
+@@ -404,18 +473,7 @@ export class IncrementalCache implements IncrementalCacheType {
+       bodyChunks,
+     ])
+ 
+-    if (process.env.NEXT_RUNTIME === 'edge') {
+-      function bufferToHex(buffer: ArrayBuffer): string {
+-        return Array.prototype.map
+-          .call(new Uint8Array(buffer), (b) => b.toString(16).padStart(2, '0'))
+-          .join('')
+-      }
+-      const buffer = encoder.encode(cacheString)
+-      return bufferToHex(await crypto.subtle.digest('SHA-256', buffer))
+-    } else {
+-      const crypto = require('crypto') as typeof import('crypto')
+-      return crypto.createHash('sha256').update(cacheString).digest('hex')
+-    }
++    return hashString(cacheString)
+   }
+ 
+   async get(
+diff --git a/packages/next/src/server/lib/patch-fetch.ts b/packages/next/src/server/lib/patch-fetch.ts
+index 4be72496f1..b7e8b124c4 100644
+--- a/packages/next/src/server/lib/patch-fetch.ts
++++ b/packages/next/src/server/lib/patch-fetch.ts
+@@ -820,8 +820,8 @@ export function createPatchedFetcher(
+               fetchUrl,
+               isRequestInput ? (input as RequestInit) : init
+             )
+-          } catch (err) {
+-            console.error(`Failed to generate cache key for`, input)
++          } catch (cause) {
++            console.error(`Failed to generate cache key for`, input, cause)
+           }
+         }
+ 
+diff --git a/packages/next/src/server/web/spec-extension/unstable-cache.ts b/packages/next/src/server/web/spec-extension/unstable-cache.ts
+index 9027330881..5c3aac47c7 100644
+--- a/packages/next/src/server/web/spec-extension/unstable-cache.ts
++++ b/packages/next/src/server/web/spec-extension/unstable-cache.ts
+@@ -134,7 +134,8 @@ export function unstable_cache<T extends Callback>(
+       // @TODO stringify is likely not safe here. We will coerce undefined to null which will make
+       // the keyspace smaller than the execution space
+       const invocationKey = `${fixedKey}-${JSON.stringify(args)}`
+-      const cacheKey = await incrementalCache.generateCacheKey(invocationKey)
++      const cacheKey =
++        await incrementalCache.generateSimpleCacheKey(invocationKey)
+       // $urlWithPath,$sortedQueryStringKeys,$hashOfEveryThingElse
+       const fetchUrl = `unstable_cache ${fetchUrlPrefix} ${cb.name ? ` ${cb.name}` : cacheKey}`
+       const fetchIdx =

nextjs-byte-exact-binary-fetch-cache-keys/solution/solve.sh

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

nextjs-cache-components-dynamic-param-prerenders/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' \
+    && 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-components-dynamic-param-prerenders/solution/gold.patch

@@ -0,0 +1,139 @@
+diff --git a/packages/next/src/build/adapter/build-complete.ts b/packages/next/src/build/adapter/build-complete.ts
+index 48757853f6..167adb54b5 100644
+--- a/packages/next/src/build/adapter/build-complete.ts
++++ b/packages/next/src/build/adapter/build-complete.ts
+@@ -1585,6 +1585,7 @@ export async function handleBuildComplete({
+         const canEmitPartialFallback =
+           partialFallback && fallbackRootParams?.length === 0
+         let htmlAllowQuery = allowQuery
++        let didFilterBlockingAllowQuery = false
+ 
+         // We only want to vary on the shell contents if there is a fallback
+         // present and able to be served.
+@@ -1615,6 +1616,35 @@ export async function handleBuildComplete({
+                   )
+                 : []
+           }
++        } else if (
++          fallback === null &&
++          isAppPage &&
++          renderingMode === RenderingMode.PARTIALLY_STATIC &&
++          routesManifest.rsc.clientParamParsing &&
++          remainingPrerenderableParams !== undefined
++        ) {
++          // BLOCKING entries (no servable fallback) still cache their
++          // on-demand renders, so the same cache-key contract applies as for
++          // partial fallbacks: only params that `generateStaticParams` can
++          // still provide may partition the cache — root params (which are
++          // always provided) and the remaining prerenderable params.
++          // Including a never-prerenderable param would create a cache entry
++          // per param value and resolve the param into the cached content,
++          // so it must be stripped from the request instead, which defers it
++          // to a per-request resume.
++          const prerenderableQueryKeys = new Set<string>()
++          for (const paramName of fallbackRootParams ?? []) {
++            prerenderableQueryKeys.add(`${NEXT_QUERY_PARAM_PREFIX}${paramName}`)
++          }
++          for (const param of remainingPrerenderableParams) {
++            prerenderableQueryKeys.add(
++              `${NEXT_QUERY_PARAM_PREFIX}${param.paramName}`
++            )
++          }
++          htmlAllowQuery = allowQuery.filter((routeKey) =>
++            prerenderableQueryKeys.has(routeKey)
++          )
++          didFilterBlockingAllowQuery = true
+         }
+ 
+         const initialOutput: AdapterOutput['PRERENDER'] = {
+@@ -1699,6 +1729,12 @@ export async function handleBuildComplete({
+             if (routesManifest.rsc.clientParamParsing) {
+               dataAllowQuery = htmlAllowQuery
+             }
++          } else if (didFilterBlockingAllowQuery) {
++            // Blocking entries have no fallback shell whose presence could
++            // make the data route vary differently from the HTML route: the
++            // on-demand data render is cached under the same
++            // prerenderable-params-only contract.
++            dataAllowQuery = htmlAllowQuery
+           }
+ 
+           if (renderingMode === RenderingMode.PARTIALLY_STATIC) {
+diff --git a/packages/next/src/build/templates/app-page.ts b/packages/next/src/build/templates/app-page.ts
+index 227259ded5..beed2e5216 100644
+--- a/packages/next/src/build/templates/app-page.ts
++++ b/packages/next/src/build/templates/app-page.ts
+@@ -585,6 +585,7 @@ export async function handler(
+     (prerenderInfo.fallbackRootParams?.length ?? 0) > 0
+ 
+   let ssgCacheKey: string | null = null
++  let usesCompletedShellCacheKey = false
+   if (
+     !isDraftMode &&
+     isSSG &&
+@@ -597,17 +598,19 @@ export async function handler(
+     // partial fallbacks we instead derive the cache key from the shell
+     // that matched this request so `/prefix/[one]/[two]` can specialize into
+     // `/prefix/c/[two]` without promoting all the way to `/prefix/c/foo`.
++    // This includes entries with unresolved ROOT params: those requests are
++    // served blocking (no shell can be shared across root branches), but
++    // the entry they produce is still keyed by the completed shell — root
++    // params and any other prerenderable params resolve into the key while
++    // params that `generateStaticParams` can never provide stay as
++    // placeholders and must not partition the cache.
+     const fallbackPathname = prerenderMatch
+       ? typeof prerenderInfo?.fallback === 'string'
+         ? prerenderInfo.fallback
+         : prerenderMatch.source
+       : null
+ 
+-    if (
+-      fallbackPathname &&
+-      prerenderInfo?.fallbackRouteParams?.length &&
+-      !hasUnresolvedRootFallbackParams
+-    ) {
++    if (fallbackPathname && prerenderInfo?.fallbackRouteParams?.length) {
+       if (remainingPrerenderableParams.length > 0) {
+         const completedShellCacheKey = buildCompletedShellCacheKey(
+           fallbackPathname,
+@@ -618,10 +621,10 @@ export async function handler(
+         // If applying the current request params doesn't make the shell any
+         // more complete, then this shell is already at its most complete
+         // form and should remain shared rather than creating a new cache entry.
+-        ssgCacheKey =
+-          completedShellCacheKey !== fallbackPathname
+-            ? completedShellCacheKey
+-            : null
++        if (completedShellCacheKey !== fallbackPathname) {
++          ssgCacheKey = completedShellCacheKey
++          usesCompletedShellCacheKey = true
++        }
+       }
+     } else {
+       ssgCacheKey = resolvedPathname
+@@ -1494,9 +1497,22 @@ export async function handler(
+                 effectiveFallbackRouteParams.length <
+                   (prerenderInfo?.fallbackRouteParams?.length ?? 0)
+               ? createOpaqueFallbackRouteParams(effectiveFallbackRouteParams)
+-              : isDebugFallbackShell
+-                ? getFallbackRouteParams(normalizedSrcPage, routeModule)
+-                : null
++              : // A render cached under a completed shell cache key must keep
++                // deferring the params the key leaves as placeholders (the
++                // ones `generateStaticParams` can never provide) so they
++                // resume per request instead of baking into the shared entry.
++                // This is the blocking analog of the background shell
++                // upgrade above and is likewise self-hosted only: in minimal
++                // mode the platform proxy owns this contract by stripping
++                // never-prerenderable params from the request, which defers
++                // them through the placeholder handling instead.
++                !isMinimalMode &&
++                  usesCompletedShellCacheKey &&
++                  remainingFallbackRouteParams.length > 0
++                ? createOpaqueFallbackRouteParams(remainingFallbackRouteParams)
++                : isDebugFallbackShell
++                  ? getFallbackRouteParams(normalizedSrcPage, routeModule)
++                  : null
+ 
+         // For staged dynamic rendering (Cached Navigations) and debug static
+         // shell rendering, pass the fallback params via request meta so the

nextjs-cache-components-dynamic-param-prerenders/solution/solve.sh

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

nextjs-cache-components-dynamic-param-prerenders/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' \
+    && 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-components-dynamic-param-prerenders/tests/test.patch

@@ -0,0 +1,440 @@
+diff --git a/test/e2e/app-dir/partial-fallback-root-blocking/next.config.js b/test/e2e/app-dir/partial-fallback-root-blocking/next.config.js
+index e64bae22..5e50f0b7 100644
+--- a/test/e2e/app-dir/partial-fallback-root-blocking/next.config.js
++++ b/test/e2e/app-dir/partial-fallback-root-blocking/next.config.js
+@@ -3,6 +3,7 @@
+  */
+ const nextConfig = {
+   cacheComponents: true,
++  partialPrefetching: true,
+ }
+ 
+ module.exports = nextConfig
+diff --git a/test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts b/test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts
+index 76293240..bfe46a4a 100644
+--- a/test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts
++++ b/test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts
+@@ -42,22 +42,29 @@ describe('partial-fallback-root-blocking', () => {
+ 
+   // TODO: Re-enable once infra supports multiple layers of fallbacks
+   if (!isNextDeploy) {
+-    it('should not reuse a shared shell cache entry for unknown root branches', async () => {
++    it('should serve unknown root branches with the root param resolved and other params deferred', async () => {
+       const firstResult = await fetchSplitHTML('/fr/two')
+ 
+       expect(firstResult.response.status).toBe(200)
+       expect(firstResult.static$('#lang-fallback').length).toBe(0)
+       expect(firstResult.static$('#lang').text()).toBe('fr')
+-      expect(firstResult.static$('#slug').text()).toBe('two')
+-      expect(firstResult.dynamicPart).toBe('')
++
++      expect(firstResult.static$('#slug-fallback').text()).toBe(
++        'loading slug...'
++      )
++      expect(firstResult.static$('#slug').length).toBe(0)
++      expect(firstResult.dynamicPart).toContain('<div id="slug">two</div>')
+ 
+       const secondResult = await fetchSplitHTML('/fr/other')
+ 
+       expect(secondResult.response.status).toBe(200)
+       expect(secondResult.static$('#lang-fallback').length).toBe(0)
+       expect(secondResult.static$('#lang').text()).toBe('fr')
+-      expect(secondResult.static$('#slug').text()).toBe('other')
+-      expect(secondResult.dynamicPart).toBe('')
++      expect(secondResult.static$('#slug-fallback').text()).toBe(
++        'loading slug...'
++      )
++      expect(secondResult.static$('#slug').length).toBe(0)
++      expect(secondResult.dynamicPart).toContain('<div id="slug">other</div>')
+     })
+   }
+ 
+diff --git a/test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.test.ts b/test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.test.ts
+new file mode 100644
+index 00000000..acdfa239
+--- /dev/null
++++ b/test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.test.ts
+@@ -0,0 +1,132 @@
++import { nextTestSetup } from 'e2e-utils'
++import type { NextAdapter } from 'next'
++
++describe('adapter-partial-fallback-blocking', () => {
++  const { next } = nextTestSetup({
++    files: __dirname,
++  })
++
++  function expectAllowedParams(allowQuery: string[], expected: string[]) {
++    // Adapter query allowlists are sets. Their serialized order is not part
++    // of the build output contract.
++    expect(new Set(allowQuery)).toEqual(new Set(expected))
++  }
++
++  it('should exclude never-prerenderable params from allowQuery for blocking routes with empty shells', async () => {
++    const { outputs }: Parameters<NextAdapter['onBuildComplete']>[0] =
++      await next.readJSON('build-complete.json')
++
++    const genericEmptyShellPrerender = outputs.prerenders.find(
++      (output) => output.pathname === '/empty-shell/[one]/[two]'
++    )
++    const genericEmptyShellDataPrerender = outputs.prerenders.find(
++      (output) => output.pathname === '/empty-shell/[one]/[two].rsc'
++    )
++    const genericEmptyShellSegmentPrerenders = outputs.prerenders.filter(
++      (output) =>
++        output.pathname.startsWith('/empty-shell/[one]/[two].segments/')
++    )
++    const generatedEmptyShellPrerender = outputs.prerenders.find(
++      (output) => output.pathname === '/empty-shell/a/[two]'
++    )
++
++    expect(genericEmptyShellPrerender).toBeDefined()
++    expect(genericEmptyShellDataPrerender).toBeDefined()
++    expect(genericEmptyShellSegmentPrerenders.length).toBeGreaterThan(0)
++    expect(generatedEmptyShellPrerender).toBeDefined()
++
++    expectAllowedParams(genericEmptyShellPrerender.config.allowQuery, [
++      'nxtPone',
++    ])
++    expectAllowedParams(genericEmptyShellDataPrerender.config.allowQuery, [
++      'nxtPone',
++    ])
++    for (const output of genericEmptyShellSegmentPrerenders) {
++      expectAllowedParams(output.config.allowQuery, ['nxtPone'])
++    }
++
++    expect(generatedEmptyShellPrerender.config.partialFallback).toBeUndefined()
++    expectAllowedParams(generatedEmptyShellPrerender.config.allowQuery, [])
++  })
++
++  it('should exclude never-prerenderable params from allowQuery for entries with a resolved root param', async () => {
++    const { outputs }: Parameters<NextAdapter['onBuildComplete']>[0] =
++      await next.readJSON('build-complete.json')
++
++    const emptyShellPrerender = outputs.prerenders.find(
++      (output) =>
++        output.pathname === '/with-root-param/en/empty-shell/[category]/[id]'
++    )
++    const emptyShellDataPrerender = outputs.prerenders.find(
++      (output) =>
++        output.pathname ===
++        '/with-root-param/en/empty-shell/[category]/[id].rsc'
++    )
++    const nonEmptyShellPrerender = outputs.prerenders.find(
++      (output) =>
++        output.pathname ===
++        '/with-root-param/en/non-empty-shell/[category]/[id]'
++    )
++    const emptyShellLeafPrerender = outputs.prerenders.find(
++      (output) =>
++        output.pathname === '/with-root-param/en/empty-shell/shoes/[id]'
++    )
++
++    expect(emptyShellPrerender).toBeDefined()
++    expect(emptyShellDataPrerender).toBeDefined()
++    expect(nonEmptyShellPrerender).toBeDefined()
++    expect(emptyShellLeafPrerender).toBeDefined()
++
++    expectAllowedParams(emptyShellPrerender.config.allowQuery, [
++      'nxtPcategory',
++    ])
++    expectAllowedParams(emptyShellDataPrerender.config.allowQuery, [
++      'nxtPcategory',
++    ])
++
++    expectAllowedParams(nonEmptyShellPrerender.config.allowQuery, [
++      'nxtPcategory',
++    ])
++    expect(nonEmptyShellPrerender.config.partialFallback).toBe(true)
++
++    expectAllowedParams(emptyShellLeafPrerender.config.allowQuery, [])
++  })
++
++  it('should exclude never-prerenderable params from allowQuery for entries with an unresolved root param', async () => {
++    const { outputs }: Parameters<NextAdapter['onBuildComplete']>[0] =
++      await next.readJSON('build-complete.json')
++
++    const emptyShellBasePrerender = outputs.prerenders.find(
++      (output) =>
++        output.pathname ===
++        '/with-root-param/[lang]/empty-shell/[category]/[id]'
++    )
++    const emptyShellBaseDataPrerender = outputs.prerenders.find(
++      (output) =>
++        output.pathname ===
++        '/with-root-param/[lang]/empty-shell/[category]/[id].rsc'
++    )
++    const nonEmptyShellBasePrerender = outputs.prerenders.find(
++      (output) =>
++        output.pathname ===
++        '/with-root-param/[lang]/non-empty-shell/[category]/[id]'
++    )
++
++    expect(emptyShellBasePrerender).toBeDefined()
++    expect(emptyShellBaseDataPrerender).toBeDefined()
++    expect(nonEmptyShellBasePrerender).toBeDefined()
++
++    expectAllowedParams(emptyShellBasePrerender.config.allowQuery, [
++      'nxtPlang',
++      'nxtPcategory',
++    ])
++    expectAllowedParams(emptyShellBaseDataPrerender.config.allowQuery, [
++      'nxtPlang',
++      'nxtPcategory',
++    ])
++    expectAllowedParams(nonEmptyShellBasePrerender.config.allowQuery, [
++      'nxtPlang',
++      'nxtPcategory',
++    ])
++  })
++})
+diff --git a/test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/empty-shell/[one]/[two]/page.tsx b/test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/empty-shell/[one]/[two]/page.tsx
+new file mode 100644
+index 00000000..65d28a99
+--- /dev/null
++++ b/test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/empty-shell/[one]/[two]/page.tsx
+@@ -0,0 +1,27 @@
++// This route intentionally produces EMPTY build-time shells: the params are
++// read outside of any Suspense boundary (and there is no loading.tsx), so the
++// postpone propagates to the root. `instant = false` opts the route out of
++// requiring an instant (non-empty) shell.
++//
++// The empty shells downgrade the generic route to a blocking route, but `two`
++// is still never provided by `generateStaticParams`: an on-demand render may
++// only complete `one`, so only `one` may participate in the cache key.
++export function generateStaticParams() {
++  return [{ one: 'a' }]
++}
++
++export const instant = false
++
++export default async function Page({
++  params,
++}: {
++  params: Promise<{ one: string; two: string }>
++}) {
++  const { one, two } = await params
++
++  return (
++    <div>
++      {one}:{two}
++    </div>
++  )
++}
+diff --git a/test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/layout.tsx b/test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/layout.tsx
+new file mode 100644
+index 00000000..e7a42507
+--- /dev/null
++++ b/test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/layout.tsx
+@@ -0,0 +1,11 @@
++import { ReactNode } from 'react'
++
++// Root layout for the (standard) branch: all params in this branch are
++// below the root layout, so none of them are root params.
++export default function Root({ children }: { children: ReactNode }) {
++  return (
++    <html>
++      <body>{children}</body>
++    </html>
++  )
++}
+diff --git a/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/empty-shell/[category]/[id]/page.tsx b/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/empty-shell/[category]/[id]/page.tsx
+new file mode 100644
+index 00000000..d2b6d1b1
+--- /dev/null
++++ b/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/empty-shell/[category]/[id]/page.tsx
+@@ -0,0 +1,38 @@
++// Empty-shell variant under a root param: the params are read outside of
++// any Suspense boundary, so the postpone propagates to the root and every
++// build-time shell is empty. `instant = false` opts the route out of
++// requiring an instant (non-empty) shell.
++//
++// `generateStaticParams` provides `lang` in every entry (required for root
++// params) and partially covers `category`; `id` is never provided, so `id`
++// must never be resolved into a cached shell and must never be part of a
++// cache key — including for requests whose `lang` value was not enumerated
++// (e.g. /fr/...), which match the base route entry where `lang` is an
++// unresolved root param.
++export async function generateStaticParams() {
++  return [{ lang: 'en' }, { lang: 'en', category: 'shoes' }]
++}
++
++export const instant = false
++
++export default async function Page({
++  params,
++}: {
++  params: Promise<{ lang: string; category: string; id: string }>
++}) {
++  const { lang, category, id } = await params
++
++  // Per-render marker (prerenderable): must be re-rendered per request and
++  // never repeat across fetches — a repeated value proves a stored render
++  // is being replayed from the cache.
++  const renderedAt = performance.now()
++
++  return (
++    <div>
++      <div id="lang">{lang}</div>
++      <div id="category">{category}</div>
++      <div id="id">{id}</div>
++      <div id="rendered-at">{renderedAt}</div>
++    </div>
++  )
++}
+diff --git a/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/layout.tsx b/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/layout.tsx
+new file mode 100644
+index 00000000..bc155c67
+--- /dev/null
++++ b/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/layout.tsx
+@@ -0,0 +1,19 @@
++// The ROOT layout lives inside [lang], making `lang` a ROOT param: the
++// document itself (the html tag) varies by lang with no Suspense boundary.
++// Root params must be provided by every generateStaticParams result — the
++// build enforces this — so `lang` is always a prerenderable param.
++export default async function RootLayout({
++  children,
++  params,
++}: {
++  children: React.ReactNode
++  params: Promise<{ lang: string }>
++}) {
++  const { lang } = await params
++
++  return (
++    <html lang={lang}>
++      <body>{children}</body>
++    </html>
++  )
++}
+diff --git a/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/[id]/page.tsx b/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/[id]/page.tsx
+new file mode 100644
+index 00000000..ba731670
+--- /dev/null
++++ b/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/[id]/page.tsx
+@@ -0,0 +1,49 @@
++import { Suspense } from 'react'
++
++// Non-empty-shell variant under a root param: static page content plus
++// Suspense boundaries around the non-root param reads, so shells contain
++// static content and no empty-shell downgrade happens.
++//
++// `generateStaticParams` provides `lang` in every entry (required for root
++// params) and partially covers `category`; `id` is never provided and must
++// never resolve into a cached shell nor participate in a cache key.
++export async function generateStaticParams() {
++  return [{ lang: 'en' }, { lang: 'en', category: 'shoes' }]
++}
++
++async function Id({ params }: { params: Promise<{ id: string }> }) {
++  const { id } = await params
++
++  // Per-render marker (prerenderable), read after `await params` so it
++  // belongs to the deferred region: it must be re-rendered (resumed) per
++  // request and never repeat across fetches.
++  const renderedAt = performance.now()
++
++  return (
++    <>
++      <div id="id">{id}</div>
++      <div id="rendered-at">{renderedAt}</div>
++    </>
++  )
++}
++
++export default function Page({
++  params,
++}: {
++  params: Promise<{ lang: string; category: string; id: string }>
++}) {
++  return (
++    <div>
++      <div id="static">static page content</div>
++      <Suspense
++        fallback={
++          <div id="id-fallback" data-fallback>
++            loading id...
++          </div>
++        }
++      >
++        <Id params={params} />
++      </Suspense>
++    </div>
++  )
++}
+diff --git a/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/layout.tsx b/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/layout.tsx
+new file mode 100644
+index 00000000..a0da238a
+--- /dev/null
++++ b/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/layout.tsx
+@@ -0,0 +1,40 @@
++import { Suspense, type ReactNode } from 'react'
++
++// `category` is read in its own Suspense boundary: shells where it is
++// concrete render it statically, and generic shells show
++// `#category-fallback`. This makes the served shell's specialization
++// observable from the static part of the response. (`lang` is a root param
++// and is part of the document itself, rendered by the root layout.)
++async function LayoutImpl({
++  children,
++  params,
++}: {
++  children: ReactNode
++  params: Promise<{ category: string }>
++}) {
++  const { category } = await params
++
++  return (
++    <div>
++      <div id="category">{category}</div>
++      {children}
++    </div>
++  )
++}
++
++export default function Layout(props: {
++  children: ReactNode
++  params: Promise<{ category: string }>
++}) {
++  return (
++    <Suspense
++      fallback={
++        <div id="category-fallback" data-fallback>
++          loading category...
++        </div>
++      }
++    >
++      <LayoutImpl {...props} />
++    </Suspense>
++  )
++}
+diff --git a/test/production/app-dir/adapter-partial-fallback-blocking/my-adapter.mjs b/test/production/app-dir/adapter-partial-fallback-blocking/my-adapter.mjs
+new file mode 100644
+index 00000000..548129ec
+--- /dev/null
++++ b/test/production/app-dir/adapter-partial-fallback-blocking/my-adapter.mjs
+@@ -0,0 +1,9 @@
++import fs from 'fs/promises'
++
++/** @type {import('next').NextAdapter } */
++export default {
++  name: 'adapter-partial-fallback-blocking',
++  async onBuildComplete(ctx) {
++    await fs.writeFile('build-complete.json', JSON.stringify(ctx, null, 2))
++  },
++}
+diff --git a/test/production/app-dir/adapter-partial-fallback-blocking/next.config.js b/test/production/app-dir/adapter-partial-fallback-blocking/next.config.js
+new file mode 100644
+index 00000000..39584cc1
+--- /dev/null
++++ b/test/production/app-dir/adapter-partial-fallback-blocking/next.config.js
+@@ -0,0 +1,10 @@
++/**
++ * @type {import('next').NextConfig}
++ */
++const nextConfig = {
++  cacheComponents: true,
++  partialPrefetching: true,
++  adapterPath: require.resolve('./my-adapter.mjs'),
++}
++
++module.exports = nextConfig

nextjs-cache-components-dynamic-param-prerenders/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/partial-fallback-root-blocking/next.config.js' --exclude='test/e2e/app-dir/partial-fallback-root-blocking/next.config.js/*' --exclude='test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts' --exclude='test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts/*' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.test.ts' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.test.ts/*' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/empty-shell/[one]/[two]/page.tsx' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/empty-shell/[one]/[two]/page.tsx/*' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/layout.tsx' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/layout.tsx/*' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/empty-shell/[category]/[id]/page.tsx' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/empty-shell/[category]/[id]/page.tsx/*' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/layout.tsx' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/layout.tsx/*' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/[id]/page.tsx' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/[id]/page.tsx/*' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/layout.tsx' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/layout.tsx/*' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/my-adapter.mjs' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/my-adapter.mjs/*' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/next.config.js' --exclude='test/production/app-dir/adapter-partial-fallback-blocking/next.config.js/*' /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/partial-fallback-root-blocking/next.config.js' 'test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts' 'test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.test.ts' 'test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/empty-shell/[one]/[two]/page.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/layout.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/empty-shell/[category]/[id]/page.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/layout.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/[id]/page.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/layout.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/my-adapter.mjs' 'test/production/app-dir/adapter-partial-fallback-blocking/next.config.js' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/e2e/app-dir/partial-fallback-root-blocking/next.config.js' 'test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts' 'test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.test.ts' 'test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/empty-shell/[one]/[two]/page.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/layout.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/empty-shell/[category]/[id]/page.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/layout.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/[id]/page.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/layout.tsx' 'test/production/app-dir/adapter-partial-fallback-blocking/my-adapter.mjs' 'test/production/app-dir/adapter-partial-fallback-blocking/next.config.js' >/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/partial-fallback-root-blocking/next.config.js' '/app/test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts' '/app/test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.test.ts' '/app/test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/empty-shell/[one]/[two]/page.tsx' '/app/test/production/app-dir/adapter-partial-fallback-blocking/app/(standard)/layout.tsx' '/app/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/empty-shell/[category]/[id]/page.tsx' '/app/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/layout.tsx' '/app/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/[id]/page.tsx' '/app/test/production/app-dir/adapter-partial-fallback-blocking/app/with-root-param/[lang]/non-empty-shell/[category]/layout.tsx' '/app/test/production/app-dir/adapter-partial-fallback-blocking/my-adapter.mjs' '/app/test/production/app-dir/adapter-partial-fallback-blocking/next.config.js'; 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-start-webpack '"'"'test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts'"'"' '"'"'test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm build && pnpm test-start-webpack '"'"'test/e2e/app-dir/partial-fallback-root-blocking/partial-fallback-root-blocking.test.ts'"'"' '"'"'test/production/app-dir/adapter-partial-fallback-blocking/adapter-partial-fallback-blocking.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-start-webpack '"'"'test/e2e/app-dir/partial-fallback-shell-upgrade/partial-fallback-shell-upgrade.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-client-node-browser-variants/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 && pnpm install --frozen-lockfile && 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-client-node-browser-variants/solution/gold.patch

@@ -0,0 +1,178 @@
+diff --git a/crates/next-core/src/browser_variant_modules.rs b/crates/next-core/src/browser_variant_modules.rs
+index 1e1b9295b4..133ef25ace 100644
+--- a/crates/next-core/src/browser_variant_modules.rs
++++ b/crates/next-core/src/browser_variant_modules.rs
+@@ -11,6 +11,8 @@
+ #[rustfmt::skip]
+ pub static BROWSER_VARIANT_MODULES: &[&str] = &[
+     "client/components/client-boundary-params",
++    "client/components/instant-samples",
++    "client/components/instant-validation/impl",
+     "client/components/navigation-dynamic-rendering",
+     "client/components/server-async-storage",
+     "client/components/unstable-rethrow",
+diff --git a/packages/next/src/build/browser-variant-modules.ts b/packages/next/src/build/browser-variant-modules.ts
+index bf7685e857..45563cf715 100644
+--- a/packages/next/src/build/browser-variant-modules.ts
++++ b/packages/next/src/build/browser-variant-modules.ts
+@@ -7,6 +7,8 @@
+ // `packages/next/dist` (extension omitted).
+ export const browserVariantModules = [
+   'client/components/client-boundary-params',
++  'client/components/instant-samples',
++  'client/components/instant-validation/impl',
+   'client/components/navigation-dynamic-rendering',
+   'client/components/server-async-storage',
+   'client/components/unstable-rethrow',
+diff --git a/packages/next/src/client/components/instant-samples.browser.ts b/packages/next/src/client/components/instant-samples.browser.ts
+new file mode 100644
+index 0000000000..35c2fbf65a
+--- /dev/null
++++ b/packages/next/src/client/components/instant-samples.browser.ts
+@@ -0,0 +1,3 @@
++export const instrumentParamsForClientValidation = undefined
++export const expectCompleteParamsInClientValidation = undefined
++export const instrumentSearchParamsForClientValidation = undefined
+diff --git a/packages/next/src/server/app-render/instant-validation/instant-samples-client.ts b/packages/next/src/client/components/instant-samples.ts
+similarity index 88%
+rename from packages/next/src/server/app-render/instant-validation/instant-samples-client.ts
+rename to packages/next/src/client/components/instant-samples.ts
+index 15101787cb..7bd30ba8b1 100644
+--- a/packages/next/src/server/app-render/instant-validation/instant-samples-client.ts
++++ b/packages/next/src/client/components/instant-samples.ts
+@@ -1,13 +1,13 @@
+-import type { Params } from '../../request/params'
+-import type { ReadonlyURLSearchParams } from '../../../client/components/readonly-url-search-params'
+-import { workUnitAsyncStorage } from '../work-unit-async-storage.external'
+-import { workAsyncStorage } from '../work-async-storage.external'
++import type { Params } from '../../server/request/params'
++import type { ReadonlyURLSearchParams } from './readonly-url-search-params'
++import { workUnitAsyncStorage } from '../../server/app-render/work-unit-async-storage.external'
++import { workAsyncStorage } from '../../server/app-render/work-async-storage.external'
+ import {
+   createExhaustiveParamsProxy,
+   createExhaustiveURLSearchParamsProxy,
+   trackMissingSampleErrorAndThrow,
+-} from './instant-samples'
+-import { InstantValidationError } from './instant-validation-error'
++} from '../../server/app-render/instant-validation/instant-samples'
++import { InstantValidationError } from '../../server/app-render/instant-validation/instant-validation-error'
+ 
+ export function instrumentParamsForClientValidation<TPArams extends Params>(
+   underlyingParams: TPArams
+diff --git a/packages/next/src/client/components/instant-validation/boundary.tsx b/packages/next/src/client/components/instant-validation/boundary.tsx
+index cf39318c3a..8ed8ccd7fe 100644
+--- a/packages/next/src/client/components/instant-validation/boundary.tsx
++++ b/packages/next/src/client/components/instant-validation/boundary.tsx
+@@ -1,29 +1,9 @@
+ 'use client'
+-
+-// This facade ensures that the boundary code is DCE'd in browser bundles.
+-//
+-// It also exists to satisfy `browser-chunks.test.ts`, which looks for
+-// references to code in `packages/next/src/server` in browser bundles and errors if it finds any.
+-// A "use client" module seems to always have always have an entry in the browser bundle,
+-// so this module cannot be colocated with the rest of the instant validation code,
+-// because it ends up looking like it's importing server code in the browser
+-// even though all the server code inside is actually DCE'd.
+-
+-const {
+-  InstantValidationBoundaryContext,
+-  PlaceValidationBoundaryBelowThisLevel,
+-  RenderValidationBoundaryAtThisLevel,
+-  SlotMarker,
+-} =
+-  typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS
+-    ? // TODO(browser-variant): migrate to a .ts/.browser.ts split so the browser bundle drops the server branch; see scripts/generate-browser-variant-aliases.mjs
+-      // ast-grep-ignore: no-typeof-window-require-tsx
+-      (require('../../../server/app-render/instant-validation/boundary-impl') as typeof import('../../../server/app-render/instant-validation/boundary-impl'))
+-    : ({} as typeof import('../../../server/app-render/instant-validation/boundary-impl'))
+-
++// We can't fork a `use client` boundary based on node-client vs browser-client.
++// We need to fork one level deeper.
+ export {
+   InstantValidationBoundaryContext,
+   PlaceValidationBoundaryBelowThisLevel,
+   RenderValidationBoundaryAtThisLevel,
+   SlotMarker,
+-}
++} from './impl'
+diff --git a/packages/next/src/client/components/instant-validation/impl.browser.tsx b/packages/next/src/client/components/instant-validation/impl.browser.tsx
+new file mode 100644
+index 0000000000..fad4049807
+--- /dev/null
++++ b/packages/next/src/client/components/instant-validation/impl.browser.tsx
+@@ -0,0 +1,4 @@
++export const InstantValidationBoundaryContext = null
++export const PlaceValidationBoundaryBelowThisLevel = null
++export const RenderValidationBoundaryAtThisLevel = null
++export const SlotMarker = null
+diff --git a/packages/next/src/client/components/instant-validation/impl.tsx b/packages/next/src/client/components/instant-validation/impl.tsx
+new file mode 100644
+index 0000000000..62e291f209
+--- /dev/null
++++ b/packages/next/src/client/components/instant-validation/impl.tsx
+@@ -0,0 +1,6 @@
++export {
++  InstantValidationBoundaryContext,
++  PlaceValidationBoundaryBelowThisLevel,
++  RenderValidationBoundaryAtThisLevel,
++  SlotMarker,
++} from '../../../server/app-render/instant-validation/boundary-impl'
+diff --git a/packages/next/src/client/components/layout-router.tsx b/packages/next/src/client/components/layout-router.tsx
+index efdd8d9187..52019013c5 100644
+--- a/packages/next/src/client/components/layout-router.tsx
++++ b/packages/next/src/client/components/layout-router.tsx
+@@ -33,6 +33,10 @@ import { ErrorBoundary } from './error-boundary'
+ import { disableSmoothScrollDuringRouteTransition } from '../../shared/lib/router/utils/disable-smooth-scroll'
+ import { RedirectBoundary } from './redirect-boundary'
+ import { HTTPAccessFallbackBoundary } from './http-access-fallback/error-boundary'
++import {
++  InstantValidationBoundaryContext,
++  RenderValidationBoundaryAtThisLevel,
++} from './instant-validation/boundary'
+ import { createRouterCacheKey } from './router-reducer/create-router-cache-key'
+ import {
+   useRouterBFCache,
+@@ -670,10 +674,6 @@ export default function OuterLayoutRouter({
+ 
+   let maybeValidationBoundaryId: string | null = null
+   if (typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS) {
+-    const { InstantValidationBoundaryContext } =
+-      // TODO(browser-variant): migrate to a .ts/.browser.ts split so the browser bundle drops the server branch; see scripts/generate-browser-variant-aliases.mjs
+-      // ast-grep-ignore: no-typeof-window-require-tsx
+-      require('./instant-validation/boundary') as typeof import('./instant-validation/boundary')
+     maybeValidationBoundaryId = use(InstantValidationBoundaryContext)
+   }
+ 
+@@ -812,10 +812,6 @@ export default function OuterLayoutRouter({
+       process.env.__NEXT_CACHE_COMPONENTS &&
+       typeof maybeValidationBoundaryId === 'string'
+     ) {
+-      const { RenderValidationBoundaryAtThisLevel } =
+-        // TODO(browser-variant): migrate to a .ts/.browser.ts split so the browser bundle drops the server branch; see scripts/generate-browser-variant-aliases.mjs
+-        // ast-grep-ignore: no-typeof-window-require-tsx
+-        require('./instant-validation/boundary') as typeof import('./instant-validation/boundary')
+       templateValue = (
+         <RenderValidationBoundaryAtThisLevel id={maybeValidationBoundaryId}>
+           {templateValue}
+diff --git a/packages/next/src/client/components/navigation.ts b/packages/next/src/client/components/navigation.ts
+index 0c7dc84d32..2e1df203d8 100644
+--- a/packages/next/src/client/components/navigation.ts
++++ b/packages/next/src/client/components/navigation.ts
+@@ -27,12 +27,9 @@ const {
+   instrumentParamsForClientValidation,
+   instrumentSearchParamsForClientValidation,
+   expectCompleteParamsInClientValidation,
+-} =
+-  typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS
+-    ? // TODO(browser-variant): migrate to a .ts/.browser.ts split so the browser bundle drops the server branch; see scripts/generate-browser-variant-aliases.mjs
+-      // ast-grep-ignore: no-typeof-window-require
+-      (require('../../server/app-render/instant-validation/instant-samples-client') as typeof import('../../server/app-render/instant-validation/instant-samples-client'))
+-    : {}
++} = process.env.__NEXT_CACHE_COMPONENTS
++  ? (require('./instant-samples') as typeof import('./instant-samples'))
++  : {}
+ 
+ /**
+  * A [Client Component](https://nextjs.org/docs/app/building-your-application/rendering/client-components) hook

nextjs-client-node-browser-variants/solution/solve.sh

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

nextjs-client-node-browser-variants/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 && pnpm install --frozen-lockfile && 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-client-node-browser-variants/tests/test.patch

@@ -0,0 +1,109 @@
+diff --git a/test/production/app-dir/browser-chunks/browser-chunks.test.ts b/test/production/app-dir/browser-chunks/browser-chunks.test.ts
+index 041a813ad0..ecf810fcb3 100644
+--- a/test/production/app-dir/browser-chunks/browser-chunks.test.ts
++++ b/test/production/app-dir/browser-chunks/browser-chunks.test.ts
+@@ -22,6 +22,14 @@ function normalizeSource(source: string): string {
+ describe('browser-chunks', () => {
+   const { next } = nextTestSetup({
+     files: __dirname,
++    dependencies: {
++      react: '19.2.7',
++      'react-dom': '19.2.7',
++      '@types/react': '19.2.2',
++      '@types/react-dom': '19.2.1',
++      typescript: '6.0.2',
++      '@types/node': '20.17.6',
++    },
+   })
+ 
+   let sources: string[] = []
+@@ -45,13 +53,11 @@ describe('browser-chunks', () => {
+     )
+   })
+ 
+-  // These snapshots document which matching modules currently reach browser
+-  // chunks. Some of these we don't intend to act on yet, so we snapshot the
+-  // normalized paths (rather than hard-fail) to surface regressions on review.
+   it('must not bundle any server modules into browser chunks', () => {
+     const serverSources = Array.from(
+       new Set(
+         sources
++          // normalizing in case we regress and want to keep track of the regression
+           .map(normalizeSource)
+           .filter(
+             (source) =>
+@@ -63,46 +69,7 @@ describe('browser-chunks', () => {
+       )
+     ).sort()
+ 
+-    // This set varies along two axes, so snapshot each combination separately
+-    // rather than forcing them to agree:
+-    //   - bundler: webpack's browser chunks contain none of these; Turbopack
+-    //     still pulls in a set we haven't acted on yet.
+-    //   - cache components: enabling it pulls additional server modules
+-    //     (instant-validation, async storage, dynamic rendering) into the
+-    //     client render path. CI runs this suite both with and without it
+-    //     (see test/cache-components-tests-manifest.json).
+-    const cacheComponents = process.env.__NEXT_CACHE_COMPONENTS === 'true'
+-    if (process.env.IS_TURBOPACK_TEST) {
+-      if (cacheComponents) {
+-        expect(serverSources).toMatchInlineSnapshot(`
+-         [
+-           "src/server/app-render/async-local-storage.ts",
+-           "src/server/app-render/instant-validation/boundary-constants.ts",
+-           "src/server/app-render/instant-validation/boundary-impl.tsx",
+-           "src/server/app-render/instant-validation/instant-samples-client.ts",
+-           "src/server/app-render/instant-validation/instant-samples.ts",
+-           "src/server/app-render/instant-validation/instant-validation-error.ts",
+-           "src/server/app-render/staged-rendering.ts",
+-           "src/server/app-render/work-async-storage-instance.ts",
+-           "src/server/app-render/work-async-storage.external.ts",
+-           "src/server/app-render/work-unit-async-storage-instance.ts",
+-           "src/server/app-render/work-unit-async-storage.external.ts",
+-           "src/server/web/spec-extension/adapters/headers.ts",
+-           "src/server/web/spec-extension/adapters/reflect.ts",
+-           "src/server/web/spec-extension/adapters/request-cookies.ts",
+-           "src/server/web/spec-extension/cookies.ts",
+-         ]
+-        `)
+-      } else {
+-        expect(serverSources).toMatchInlineSnapshot(`[]`)
+-      }
+-    } else {
+-      if (cacheComponents) {
+-        expect(serverSources).toMatchInlineSnapshot(`[]`)
+-      } else {
+-        expect(serverSources).toMatchInlineSnapshot(`[]`)
+-      }
+-    }
++    expect(serverSources).toEqual([])
+   })
+ 
+   it('must not bundle any dev overlay into browser chunks', () => {
+diff --git a/test/production/app-dir/browser-chunks/browser-runtime.test.ts b/test/production/app-dir/browser-chunks/browser-runtime.test.ts
+new file mode 100644
+index 0000000000..1891353f1f
+--- /dev/null
++++ b/test/production/app-dir/browser-chunks/browser-runtime.test.ts
+@@ -0,0 +1,21 @@
++import { nextTestSetup } from 'e2e-utils'
++
++describe('browser runtime', () => {
++  const { next } = nextTestSetup({
++    files: __dirname,
++    dependencies: {
++      react: '19.2.7',
++      'react-dom': '19.2.7',
++      '@types/react': '19.2.2',
++      '@types/react-dom': '19.2.1',
++      typescript: '6.0.2',
++      '@types/node': '20.17.6',
++    },
++  })
++
++  it('serves the client application in production', async () => {
++    const response = await next.fetch('/')
++
++    expect(response.status).toBe(200)
++  })
++})

nextjs-client-node-browser-variants/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/browser-chunks/browser-chunks.test.ts' --exclude='test/production/app-dir/browser-chunks/browser-chunks.test.ts/*' --exclude='test/production/app-dir/browser-chunks/browser-runtime.test.ts' --exclude='test/production/app-dir/browser-chunks/browser-runtime.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/browser-chunks/browser-chunks.test.ts' 'test/production/app-dir/browser-chunks/browser-runtime.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/production/app-dir/browser-chunks/browser-chunks.test.ts' 'test/production/app-dir/browser-chunks/browser-runtime.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/browser-chunks/browser-chunks.test.ts' '/app/test/production/app-dir/browser-chunks/browser-runtime.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 swc-build-native && pnpm build && pnpm test-start-experimental-turbo '"'"'test/production/app-dir/browser-chunks/browser-chunks.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm swc-build-native && pnpm build && pnpm test-start-experimental-turbo '"'"'test/production/app-dir/browser-chunks/browser-chunks.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 swc-build-native && pnpm build && pnpm test-start-experimental-turbo '"'"'test/production/app-dir/browser-chunks/browser-runtime.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-codemod-noninteractive-upgrade/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 pnpm@10.33.0 install --frozen-lockfile && corepack pnpm@10.33.0 turbo build --filter=next --filter=@next/codemod' \
+    && 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-codemod-noninteractive-upgrade/solution/gold.patch

@@ -0,0 +1,233 @@
+diff --git a/packages/next-codemod/bin/next-codemod.ts b/packages/next-codemod/bin/next-codemod.ts
+index d49ecb8e4762baeb6e02e4dc68f175a1f42de629..367412ee26feeca267d03c2e0050d2ea355fc55b 100644
+--- a/packages/next-codemod/bin/next-codemod.ts
++++ b/packages/next-codemod/bin/next-codemod.ts
+@@ -65,6 +65,11 @@ program
+   )
+   .usage('[revision] [options]')
+   .option('--verbose', 'Verbose output', false)
++  .option(
++    '-y, --yes',
++    'Skip every interactive prompt and accept its default. Also auto-enabled when stdin is not a TTY (e.g. running under an agent or in CI).',
++    false
++  )
+   .action(async (revision, options) => {
+     try {
+       await runUpgrade(revision, options)
+diff --git a/packages/next-codemod/bin/upgrade.ts b/packages/next-codemod/bin/upgrade.ts
+index b7de97ce5cb1640afb7dd2fb93028d6055330801..2cb91c140a49348bb8bbd0335a14021c0441a7cd 100644
+--- a/packages/next-codemod/bin/upgrade.ts
++++ b/packages/next-codemod/bin/upgrade.ts
+@@ -112,9 +112,15 @@ function resolveSemanticRevision(
+ 
+ export async function runUpgrade(
+   revision: string | undefined,
+-  options: { verbose: boolean }
++  options: { verbose: boolean; yes?: boolean }
+ ): Promise<void> {
+   const { verbose } = options
++  const nonInteractive = options.yes === true || !process.stdin.isTTY
++  if (nonInteractive) {
++    console.log(
++      `  Running in non-interactive mode. Every prompt will accept its default.`
++    )
++  }
+   const appPackageJsonPath = path.resolve(cwd, 'package.json')
+   let appPackageJson = JSON.parse(fs.readFileSync(appPackageJsonPath, 'utf8'))
+ 
+@@ -221,22 +227,27 @@ export async function runUpgrade(
+     // We'll recommend to upgrade in the prompt but users can decide to try 18.
+     !isPureAppRouter
+   ) {
+-    const shouldStayOnReact18Res = await prompts(
+-      {
+-        type: 'confirm',
+-        name: 'shouldStayOnReact18',
+-        message:
+-          `Do you prefer to stay on React 18?` +
+-          (isMixedApp
+-            ? " Since you're using both pages/ and app/, we recommend upgrading React to use a consistent version throughout your app."
+-            : ''),
+-        initial: false,
+-        active: 'Yes',
+-        inactive: 'No',
+-      },
+-      { onCancel }
+-    )
+-    shouldStayOnReact18 = shouldStayOnReact18Res.shouldStayOnReact18
++    if (nonInteractive) {
++      // Default: upgrade React past 18.
++      shouldStayOnReact18 = false
++    } else {
++      const shouldStayOnReact18Res = await prompts(
++        {
++          type: 'confirm',
++          name: 'shouldStayOnReact18',
++          message:
++            `Do you prefer to stay on React 18?` +
++            (isMixedApp
++              ? " Since you're using both pages/ and app/, we recommend upgrading React to use a consistent version throughout your app."
++              : ''),
++          initial: false,
++          active: 'Yes',
++          inactive: 'No',
++        },
++        { onCancel }
++      )
++      shouldStayOnReact18 = shouldStayOnReact18Res.shouldStayOnReact18
++    }
+   }
+ 
+   // We're resolving a specific version here to avoid including "ugly" version queries
+@@ -254,12 +265,13 @@ export async function runUpgrade(
+     compareVersions(targetNextVersion, '15.0.0-canary') >= 0 &&
+     compareVersions(targetNextVersion, '16.0.0-canary') < 0
+   ) {
+-    await suggestTurbopack(appPackageJson, targetNextVersion)
++    await suggestTurbopack(appPackageJson, targetNextVersion, nonInteractive)
+   }
+ 
+   const codemods = await suggestCodemods(
+     installedNextVersion,
+-    targetNextVersion
++    targetNextVersion,
++    nonInteractive
+   )
+   const packageManager: PackageManager = getPkgManager(cwd)
+ 
+@@ -272,8 +284,9 @@ export async function runUpgrade(
+     compareVersions(targetReactVersion, '19.0.0-0') >= 0 &&
+     compareVersions(installedReactVersion, '19.0.0-0') < 0
+   ) {
+-    shouldRunReactCodemods = await suggestReactCodemods()
+-    shouldRunReactTypesCodemods = await suggestReactTypesCodemods()
++    shouldRunReactCodemods = await suggestReactCodemods(nonInteractive)
++    shouldRunReactTypesCodemods =
++      await suggestReactTypesCodemods(nonInteractive)
+ 
+     execCommand = getNpxCommand(packageManager)
+   }
+@@ -400,10 +413,12 @@ export async function runUpgrade(
+   // understanding of the codemods, we run all of the applicable codemods.
+   if (shouldRunReactCodemods) {
+     // https://react.dev/blog/2024/04/25/react-19-upgrade-guide#run-all-react-19-codemods
++    // `--no-interactive` skips the interactive prompt that asks for confirmation
++    // https://github.com/codemod-com/codemod/blob/c0cf00d13161a0ec0965b6cc6bc5d54076839cc8/apps/cli/src/flags.ts#L160
++    // `--allow-dirty` is required because the upgrade above modified package.json
++    // and the lockfile; the recipe refuses to run on a dirty tree otherwise.
+     execSync(
+-      // `--no-interactive` skips the interactive prompt that asks for confirmation
+-      // https://github.com/codemod-com/codemod/blob/c0cf00d13161a0ec0965b6cc6bc5d54076839cc8/apps/cli/src/flags.ts#L160
+-      `${execCommand} codemod@latest react/19/migration-recipe --no-interactive`,
++      `${execCommand} codemod@latest react/19/migration-recipe --no-interactive --allow-dirty`,
+       { stdio: 'inherit' }
+     )
+   }
+@@ -486,7 +501,8 @@ function isUsingAppDir(projectPath: string): boolean {
+  */
+ async function suggestTurbopack(
+   packageJson: any,
+-  targetNextVersion: string
++  targetNextVersion: string,
++  nonInteractive: boolean
+ ): Promise<void> {
+   const devScript: string | undefined = packageJson.scripts?.['dev']
+   // Turbopack flag was changed from `--turbo` to `--turbopack` in v15.0.1-canary.3
+@@ -518,17 +534,21 @@ async function suggestTurbopack(
+       return
+     }
+ 
+-    const responseTurbopack = await prompts(
+-      {
+-        type: 'confirm',
+-        name: 'enable',
+-        message: `Enable Turbopack for ${pc.bold('next dev')}?`,
+-        initial: true,
+-      },
+-      { onCancel }
+-    )
++    let enable = true
++    if (!nonInteractive) {
++      const responseTurbopack = await prompts(
++        {
++          type: 'confirm',
++          name: 'enable',
++          message: `Enable Turbopack for ${pc.bold('next dev')}?`,
++          initial: true,
++        },
++        { onCancel }
++      )
++      enable = responseTurbopack.enable
++    }
+ 
+-    if (!responseTurbopack.enable) {
++    if (!enable) {
+       return
+     }
+ 
+@@ -543,6 +563,12 @@ async function suggestTurbopack(
+     `${pc.yellow('⚠')} Could not find "${pc.bold('next dev')}" in your dev script.`
+   )
+ 
++  if (nonInteractive) {
++    // Without a TTY we can't ask the user for a replacement script.
++    // Keep the existing dev script untouched.
++    return
++  }
++
+   const responseCustomDevScript = await prompts(
+     {
+       type: 'text',
+@@ -559,7 +585,8 @@ async function suggestTurbopack(
+ 
+ async function suggestCodemods(
+   initialNextVersion: string,
+-  targetNextVersion: string
++  targetNextVersion: string,
++  nonInteractive: boolean
+ ): Promise<string[]> {
+   // example:
+   // codemod version: 15.0.0-canary.45
+@@ -594,6 +621,16 @@ async function suggestCodemods(
+     return []
+   }
+ 
++  if (nonInteractive) {
++    // Default: apply every recommended codemod, matching `selected: true` below.
++    const all = relevantCodemods.map(({ value }) => value)
++    console.log(
++      `  Applying all ${pc.blue('codemods')} recommended for your upgrade:\n` +
++        all.map((value) => `    - ${value}`).join('\n')
++    )
++    return all
++  }
++
+   const { codemods } = await prompts(
+     {
+       type: 'multiselect',
+@@ -614,7 +651,10 @@ async function suggestCodemods(
+   return codemods
+ }
+ 
+-async function suggestReactCodemods(): Promise<boolean> {
++async function suggestReactCodemods(nonInteractive: boolean): Promise<boolean> {
++  if (nonInteractive) {
++    return true
++  }
+   const { runReactCodemod } = await prompts(
+     {
+       type: 'confirm',
+@@ -628,7 +668,12 @@ async function suggestReactCodemods(): Promise<boolean> {
+   return runReactCodemod
+ }
+ 
+-async function suggestReactTypesCodemods(): Promise<boolean> {
++async function suggestReactTypesCodemods(
++  nonInteractive: boolean
++): Promise<boolean> {
++  if (nonInteractive) {
++    return true
++  }
+   const { runReactTypesCodemod } = await prompts(
+     {
+       type: 'confirm',

nextjs-codemod-noninteractive-upgrade/solution/solve.sh

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

nextjs-codemod-noninteractive-upgrade/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 pnpm@10.33.0 install --frozen-lockfile && corepack pnpm@10.33.0 turbo build --filter=next --filter=@next/codemod' \
+    && 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-codemod-noninteractive-upgrade/tests/test.patch

@@ -0,0 +1,283 @@
+diff --git a/packages/next-codemod/lib/__tests__/upgrade-non-interactive.test.js b/packages/next-codemod/lib/__tests__/upgrade-non-interactive.test.js
+new file mode 100644
+index 00000000..54ca42d2
+--- /dev/null
++++ b/packages/next-codemod/lib/__tests__/upgrade-non-interactive.test.js
+@@ -0,0 +1,277 @@
++/* global jest */
++
++jest.autoMockOff()
++
++const fs = require('fs')
++const os = require('os')
++const path = require('path')
++const { spawnSync } = require('child_process')
++
++const codemodRoot = path.resolve(__dirname, '../..')
++const tsx = path.resolve(codemodRoot, '../../node_modules/.bin/tsx')
++const projects = []
++
++// The verifier setup builds the base revision before applying a candidate patch.
++// Run a source snapshot of the current package so tests see candidate changes
++// instead of stale generated JavaScript while still reusing the prebuilt
++// transforms. Copy the whole package rather than assuming that an implementation
++// must live in bin/ and lib/: a CLI may legitimately import a new source folder,
++// a JavaScript-only helper, or package metadata added by the candidate.
++function createSourceCli() {
++  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'next-codemod-cli-'))
++  projects.push(root)
++
++  const sourceFile = (file) => {
++    const relative = path.relative(codemodRoot, file)
++    const topLevel = relative.split(path.sep)[0]
++    if (topLevel === 'node_modules' || topLevel === 'transforms') return false
++
++    // Ignore a generated artifact only when its source sibling exists. This
++    // keeps candidate-authored JavaScript modules while ensuring tsx loads a
++    // changed TypeScript source file instead of JavaScript built from HEAD.
++    const sourceBase = file.replace(/(?:\.js(?:\.map)?|\.d\.ts(?:\.map)?)$/, '')
++    if (sourceBase !== file) {
++      if (fs.existsSync(`${sourceBase}.ts`)) return false
++      if (fs.existsSync(`${sourceBase}.tsx`)) return false
++    }
++    return true
++  }
++  fs.cpSync(codemodRoot, root, { recursive: true, filter: sourceFile })
++
++  for (const entry of ['node_modules', 'transforms']) {
++    fs.symlinkSync(
++      path.join(codemodRoot, entry),
++      path.join(root, entry),
++      'dir'
++    )
++  }
++
++  return path.join(root, 'bin', 'next-codemod.ts')
++}
++
++function writeJson(file, value) {
++  fs.mkdirSync(path.dirname(file), { recursive: true })
++  fs.writeFileSync(file, JSON.stringify(value, null, 2))
++}
++
++function createProject({
++  installedNext,
++  installedReact,
++  targetNext,
++  targetReact,
++  devScript,
++  pages = false,
++}) {
++  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'next-codemod-upgrade-'))
++  projects.push(dir)
++
++  writeJson(path.join(dir, 'package.json'), {
++    private: true,
++    scripts: { dev: devScript },
++    dependencies: {
++      next: installedNext,
++      react: installedReact,
++      'react-dom': installedReact,
++    },
++  })
++  writeJson(path.join(dir, 'package-lock.json'), {})
++  for (const dependency of ['next', 'react', 'react-dom']) {
++    writeJson(path.join(dir, 'node_modules', dependency, 'package.json'), {
++      name: dependency,
++      version: dependency === 'next' ? installedNext : installedReact,
++    })
++  }
++  if (pages) {
++    fs.mkdirSync(path.join(dir, 'pages'), { recursive: true })
++    fs.writeFileSync(
++      path.join(dir, 'pages', 'index.js'),
++      'export default () => null\n'
++    )
++  }
++
++  const fakeBin = path.join(dir, 'fake-bin')
++  fs.mkdirSync(fakeBin)
++  const npm = `#!/usr/bin/env node
++const fs = require('fs')
++const args = process.argv.slice(2)
++const query = args.find((arg) => arg.includes('@')) || ''
++if (args.includes('view')) {
++  if (query.startsWith('next@') && args.includes('version')) {
++    console.log(JSON.stringify(process.env.TEST_TARGET_NEXT))
++  } else if (query.startsWith('next@')) {
++    console.log(JSON.stringify({ version: process.env.TEST_TARGET_NEXT, peerDependencies: { react: process.env.TEST_REACT_RANGE } }))
++  } else {
++    console.log(JSON.stringify(process.env.TEST_TARGET_REACT))
++  }
++} else {
++  fs.appendFileSync(process.env.TEST_COMMAND_LOG, 'npm ' + args.join(' ') + '\\n')
++}
++`
++  const npx = `#!/usr/bin/env node
++require('fs').appendFileSync(process.env.TEST_COMMAND_LOG, 'npx ' + process.argv.slice(2).join(' ') + '\\n')
++`
++  for (const [name, contents] of [
++    ['npm', npm],
++    ['npx', npx],
++  ]) {
++    const file = path.join(fakeBin, name)
++    fs.writeFileSync(file, contents)
++    fs.chmodSync(file, 0o755)
++  }
++
++  return {
++    dir,
++    cli: createSourceCli(),
++    commandLog: path.join(dir, 'commands.log'),
++    env: {
++      ...process.env,
++      PATH: `${fakeBin}${path.delimiter}${process.env.PATH}`,
++      TEST_TARGET_NEXT: targetNext,
++      TEST_TARGET_REACT: targetReact,
++      TEST_REACT_RANGE: `^${targetReact}`,
++      TEST_COMMAND_LOG: path.join(dir, 'commands.log'),
++      FORCE_COLOR: '0',
++    },
++  }
++}
++
++function runUpgrade(project, args, { tty = false, input } = {}) {
++  if (!tty) {
++    return spawnSync(tsx, [project.cli, 'upgrade', ...args], {
++      cwd: project.dir,
++      env: project.env,
++      encoding: 'utf8',
++      timeout: 15_000,
++    })
++  }
++
++  const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`
++  const command = [tsx, project.cli, 'upgrade', ...args].map(quote).join(' ')
++  return spawnSync('script', ['-q', '-e', '-c', command, '/dev/null'], {
++    cwd: project.dir,
++    env: project.env,
++    encoding: 'utf8',
++    timeout: 15_000,
++    input,
++  })
++}
++
++function outputOf(result) {
++  return `${result.stdout || ''}\n${result.stderr || ''}`
++}
++
++afterEach(() => {
++  while (projects.length) {
++    fs.rmSync(projects.pop(), { recursive: true, force: true })
++  }
++})
++
++test('upgrade help exposes both non-interactive option spellings', () => {
++  const cli = createSourceCli()
++  const result = spawnSync(tsx, [cli, 'upgrade', '--help'], {
++    encoding: 'utf8',
++    timeout: 15_000,
++  })
++
++  expect(result.status).toBe(0)
++  expect(outputOf(result)).toMatch(/-y, --yes\b/)
++})
++
++test('TTY use without --yes remains interactive', () => {
++  const project = createProject({
++    installedNext: '15.0.0-canary.90',
++    installedReact: '19.0.0',
++    targetNext: '15.0.0-canary.100',
++    targetReact: '19.0.0',
++    devScript: 'next dev',
++  })
++
++  // Reject the default Turbopack suggestion. A command that incorrectly forces
++  // non-interactive defaults would update this script instead.
++  const result = runUpgrade(project, ['15.0.0-canary.100'], {
++    tty: true,
++    input: 'n\n',
++  })
++  expect(outputOf(result)).toContain('Enable Turbopack')
++  expect(result.status).toBe(0)
++
++  const manifest = JSON.parse(
++    fs.readFileSync(path.join(project.dir, 'package.json'), 'utf8')
++  )
++  expect(manifest.scripts.dev).toBe('next dev')
++})
++
++test('--yes accepts prompt defaults even when the command has a TTY', () => {
++  const project = createProject({
++    installedNext: '15.0.0-canary.90',
++    installedReact: '18.2.0',
++    targetNext: '15.0.0-canary.100',
++    targetReact: '19.0.0',
++    devScript: 'next dev',
++    pages: true,
++  })
++
++  const result = runUpgrade(project, ['15.0.0-canary.100', '--yes'], {
++    tty: true,
++  })
++  expect(result.status).toBe(0)
++
++  const manifest = JSON.parse(
++    fs.readFileSync(path.join(project.dir, 'package.json'), 'utf8')
++  )
++  expect(manifest.scripts.dev).toContain('next dev --turbo')
++  expect(manifest.dependencies.next).toBe('15.0.0-canary.100')
++  expect(manifest.dependencies.react).toBe('19.0.0')
++  expect(manifest.dependencies['react-dom']).toBe('19.0.0')
++
++  const commands = fs.readFileSync(project.commandLog, 'utf8')
++  expect(commands).toContain('react/19/migration-recipe')
++  expect(commands).toContain('types-react-codemod@latest')
++})
++
++test('piped stdin automatically leaves an unrecognized custom dev script unchanged', () => {
++  const devScript = 'node scripts/start-development.js --inspect'
++  const project = createProject({
++    installedNext: '15.0.0-canary.90',
++    installedReact: '19.0.0',
++    targetNext: '15.0.0-canary.100',
++    targetReact: '19.0.0',
++    devScript,
++  })
++
++  const result = runUpgrade(project, ['15.0.0-canary.100'])
++  expect(result.status).toBe(0)
++  const manifest = JSON.parse(
++    fs.readFileSync(path.join(project.dir, 'package.json'), 'utf8')
++  )
++  expect(manifest.scripts.dev).toBe(devScript)
++  expect(manifest.dependencies.next).toBe('15.0.0-canary.100')
++})
++
++test('piped stdin applies every recommended Next.js codemod', () => {
++  const project = createProject({
++    installedNext: '13.5.0',
++    installedReact: '18.2.0',
++    targetNext: '14.2.0',
++    targetReact: '18.3.1',
++    devScript: 'next dev',
++  })
++  const page = path.join(project.dir, 'app', 'page.tsx')
++  fs.mkdirSync(path.dirname(page), { recursive: true })
++  fs.writeFileSync(
++    page,
++    `import { ImageResponse } from 'next/server'\n\nexport const metadata = {\n  title: 'Keep this title',\n  viewport: { width: 'device-width' },\n  themeColor: 'black',\n}\n\nexport default function Page() { return null }\n`
++  )
++
++  const result = runUpgrade(project, ['14.2.0'])
++  expect(result.status).toBe(0)
++
++  const output = outputOf(result)
++  expect(output).toContain('metadata-to-viewport-export')
++  expect(output).toContain('next-og-import')
++
++  const transformed = fs.readFileSync(page, 'utf8')
++  expect(transformed).toMatch(/from ['"]next\/og['"]/)
++  expect(transformed).toContain('export const viewport')
++  expect(transformed).toContain("title: 'Keep this title'")
++})

nextjs-codemod-noninteractive-upgrade/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-codemod/lib/__tests__/upgrade-non-interactive.test.js' --exclude='packages/next-codemod/lib/__tests__/upgrade-non-interactive.test.js/*' /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-codemod/lib/__tests__/upgrade-non-interactive.test.js' 2>/dev/null || true
+  git -C /app clean -fd -- 'packages/next-codemod/lib/__tests__/upgrade-non-interactive.test.js' >/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-codemod/lib/__tests__/upgrade-non-interactive.test.js'; 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 'corepack pnpm@10.33.0 test-webpack '"'"'packages/next-codemod/lib/__tests__/upgrade-non-interactive.test.js'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'corepack pnpm@10.33.0 test-webpack '"'"'packages/next-codemod/lib/__tests__/upgrade-non-interactive.test.js'"'"''; 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 'corepack pnpm@10.33.0 test-webpack '"'"'packages/next-codemod/transforms/__tests__/remove-unstable-prefix.test.js'"'"''; 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-hybrid-router-adapter-not-found/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' \
+    && 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-hybrid-router-adapter-not-found/solution/gold.patch

@@ -0,0 +1,48 @@
+diff --git a/packages/next/src/server/request-meta.ts b/packages/next/src/server/request-meta.ts
+index 0521765ea2..e8a421f992 100644
+--- a/packages/next/src/server/request-meta.ts
++++ b/packages/next/src/server/request-meta.ts
+@@ -155,10 +155,13 @@ export interface RequestMeta {
+   isNextDataReq?: true
+ 
+   /**
+-   * Postponed state to use for resumption. If present it's assumed that the
+-   * request is for a page that has postponed (there are no guarantees that the
+-   * page actually has postponed though as it would incur an additional cache
+-   * lookup).
++   * Postponed state to use for resumption. When absent, the request is not a
++   * resume request. A non-empty string contains the state to resume, while an
++   * empty string represents a resume request without postponed state and
++   * signals that the renderer should perform a full dynamic render.
++   *
++   * There are no guarantees that the page actually postponed, as verifying
++   * that would incur an additional cache lookup.
+    */
+   postponed?: string
+ 
+diff --git a/packages/next/src/server/route-modules/pages/pages-handler.ts b/packages/next/src/server/route-modules/pages/pages-handler.ts
+index 72dd63c22f..627c5747e6 100644
+--- a/packages/next/src/server/route-modules/pages/pages-handler.ts
++++ b/packages/next/src/server/route-modules/pages/pages-handler.ts
+@@ -116,6 +116,21 @@ export const getHandler = ({
+     const render404 = async () => {
+       // TODO: should route-module itself handle rendering the 404
+       if (routerServerContext?.render404) {
++        // When the Pages and App Routers coexist, a Pages Router 404 renders
++        // the App Router not-found page. A direct route-module invocation
++        // cannot provide the postponed state needed to resume that App Router
++        // output, so an empty postponed state signals that the renderer must
++        // perform a complete dynamic render instead.
++        //
++        // TODO: Re-enter routing with the App Router not-found output so its
++        // prerender and postponed state can be selected and resumed.
++        if (
++          nextConfig.cacheComponents &&
++          !routerServerContext.isWrappedByNextServer &&
++          typeof getRequestMeta(req, 'postponed') !== 'string'
++        ) {
++          addRequestMeta(req, 'postponed', '')
++        }
+         await routerServerContext.render404(req, res, parsedUrl, false)
+       } else {
+         res.end('This page could not be found')

nextjs-hybrid-router-adapter-not-found/solution/solve.sh

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

nextjs-hybrid-router-adapter-not-found/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' \
+    && 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-hybrid-router-adapter-not-found/tests/test.patch

@@ -0,0 +1,209 @@
+diff --git a/test/e2e/app-dir/pages-router-app-not-found/adapter-launcher.js b/test/e2e/app-dir/pages-router-app-not-found/adapter-launcher.js
+new file mode 100644
+index 00000000..068d62ae
+--- /dev/null
++++ b/test/e2e/app-dir/pages-router-app-not-found/adapter-launcher.js
+@@ -0,0 +1,46 @@
++// Mimics an adapter invoking a Pages output and handing its 404 render to the
++// separately compiled App Router not-found output.
++const http = require('http')
++const path = require('path')
++
++require('next/dist/build/adapter/setup-node-env.external')
++
++const dir = process.cwd()
++const port = Number(process.env.PORT)
++const pagesRoute = require(path.join(
++  dir,
++  '.next/server/pages/pages-route/[...slug].js'
++))
++const appNotFound = require(path.join(
++  dir,
++  '.next/server/app/_not-found/page.js'
++))
++
++http
++  .createServer((req, res) => {
++    const requestMeta = {
++      minimalMode: true,
++      relativeProjectDir: '.',
++      initURL: `https://localhost${req.url}`,
++      render404: async (notFoundReq, notFoundRes) => {
++        await appNotFound.handler(notFoundReq, notFoundRes, {
++          waitUntil: undefined,
++          requestMeta,
++        })
++      },
++    }
++
++    Promise.resolve(
++      pagesRoute.handler(req, res, {
++        waitUntil: undefined,
++        requestMeta,
++      })
++    ).catch((err) => {
++      console.error('handler error', err)
++      if (!res.writableEnded) {
++        res.statusCode = 500
++        res.end('internal error')
++      }
++    })
++  })
++  .listen(port, () => console.log('adapter launcher ready'))
+diff --git a/test/e2e/app-dir/pages-router-app-not-found/app/layout.tsx b/test/e2e/app-dir/pages-router-app-not-found/app/layout.tsx
+new file mode 100644
+index 00000000..888614de
+--- /dev/null
++++ b/test/e2e/app-dir/pages-router-app-not-found/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/e2e/app-dir/pages-router-app-not-found/app/not-found.tsx b/test/e2e/app-dir/pages-router-app-not-found/app/not-found.tsx
+new file mode 100644
+index 00000000..5c587676
+--- /dev/null
++++ b/test/e2e/app-dir/pages-router-app-not-found/app/not-found.tsx
+@@ -0,0 +1,20 @@
++import { Suspense } from 'react'
++import { cookies } from 'next/headers'
++
++async function DynamicNotFound() {
++  const cookieStore = await cookies()
++  const marker = cookieStore.get('not-found-marker')?.value ?? 'missing'
++
++  return <p id="dynamic-not-found">{marker}</p>
++}
++
++export default function NotFound() {
++  return (
++    <main>
++      <h1>App Router not found</h1>
++      <Suspense fallback={<p>Loading not-found content...</p>}>
++        <DynamicNotFound />
++      </Suspense>
++    </main>
++  )
++}
+diff --git a/test/e2e/app-dir/pages-router-app-not-found/app/page.tsx b/test/e2e/app-dir/pages-router-app-not-found/app/page.tsx
+new file mode 100644
+index 00000000..4f4d3de9
+--- /dev/null
++++ b/test/e2e/app-dir/pages-router-app-not-found/app/page.tsx
+@@ -0,0 +1,3 @@
++export default function Page() {
++  return <p>App Router home</p>
++}
+diff --git a/test/e2e/app-dir/pages-router-app-not-found/next.config.js b/test/e2e/app-dir/pages-router-app-not-found/next.config.js
+new file mode 100644
+index 00000000..e64bae22
+--- /dev/null
++++ b/test/e2e/app-dir/pages-router-app-not-found/next.config.js
+@@ -0,0 +1,8 @@
++/**
++ * @type {import('next').NextConfig}
++ */
++const nextConfig = {
++  cacheComponents: true,
++}
++
++module.exports = nextConfig
+diff --git a/test/e2e/app-dir/pages-router-app-not-found/pages-router-app-not-found.test.ts b/test/e2e/app-dir/pages-router-app-not-found/pages-router-app-not-found.test.ts
+new file mode 100644
+index 00000000..37a53015
+--- /dev/null
++++ b/test/e2e/app-dir/pages-router-app-not-found/pages-router-app-not-found.test.ts
+@@ -0,0 +1,65 @@
++import { spawn, type ChildProcess } from 'child_process'
++import path from 'path'
++import { nextTestSetup } from 'e2e-utils'
++import { findPort, retry } from 'next-test-utils'
++
++describe('pages-router-app-not-found', () => {
++  const { next, skipped } = nextTestSetup({
++    files: __dirname,
++    skipDeployment: true,
++    skipStart: true,
++  })
++
++  if (skipped) return
++
++  let launcher: ChildProcess
++  let port: number
++
++  beforeAll(async () => {
++    await next.build()
++
++    port = await findPort()
++    launcher = spawn('node', [path.join(next.testDir, 'adapter-launcher.js')], {
++      cwd: next.testDir,
++      env: { ...process.env, PORT: String(port) },
++      stdio: 'pipe',
++    })
++    let output = ''
++    launcher.stdout?.on('data', (chunk) => (output += chunk))
++    launcher.stderr?.on('data', (chunk) => (output += chunk))
++    await retry(async () => expect(output).toContain('adapter launcher ready'))
++  })
++
++  afterAll(() => launcher?.kill())
++
++  it('fully renders dynamic app not-found content selected by a pages route through an adapter', async () => {
++    for (const marker of ['not-found-first', 'not-found-second']) {
++      const res = await fetch(`http://localhost:${port}/pages-route/${marker}`, {
++        headers: {
++          cookie: `not-found-marker=${marker}`,
++        },
++      })
++      const html = await res.text()
++
++      expect(res.status).toBe(404)
++      expect(html).toContain('App Router not found')
++      expect(html).toContain(marker)
++    }
++  })
++
++  it('continues to render the dynamic app not-found content with next start', async () => {
++    await next.start({ skipBuild: true })
++
++    const marker = 'next-start-not-found'
++    const res = await next.fetch(`/pages-route/${marker}`, {
++      headers: {
++        cookie: `not-found-marker=${marker}`,
++      },
++    })
++    const html = await res.text()
++
++    expect(res.status).toBe(404)
++    expect(html).toContain('App Router not found')
++    expect(html).toContain(marker)
++  })
++})
+diff --git a/test/e2e/app-dir/pages-router-app-not-found/pages/pages-route/[...slug].tsx b/test/e2e/app-dir/pages-router-app-not-found/pages/pages-route/[...slug].tsx
+new file mode 100644
+index 00000000..2df13cb6
+--- /dev/null
++++ b/test/e2e/app-dir/pages-router-app-not-found/pages/pages-route/[...slug].tsx
+@@ -0,0 +1,17 @@
++export function getStaticPaths() {
++  return {
++    paths: [],
++    fallback: 'blocking',
++  }
++}
++
++export function getStaticProps() {
++  return {
++    notFound: true,
++    revalidate: 1,
++  }
++}
++
++export default function PagesRoute() {
++  return <p>This page should not render.</p>
++}

nextjs-hybrid-router-adapter-not-found/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/pages-router-app-not-found/pages-router-app-not-found.test.ts' --exclude='test/e2e/app-dir/pages-router-app-not-found/pages-router-app-not-found.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/pages-router-app-not-found/pages-router-app-not-found.test.ts' 2>/dev/null || true
+  git -C /app clean -fd -- 'test/e2e/app-dir/pages-router-app-not-found/pages-router-app-not-found.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/pages-router-app-not-found/pages-router-app-not-found.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-start-webpack '"'"'test/e2e/app-dir/pages-router-app-not-found/pages-router-app-not-found.test.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'ANALYZE=1 pnpm build && pnpm test-start-webpack '"'"'test/e2e/app-dir/pages-router-app-not-found/pages-router-app-not-found.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-navigation-server-action-in-flight/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 && ANALYZE=1 pnpm build && pnpm exec playwright install --with-deps --only-shell 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-navigation-server-action-in-flight/solution/gold.patch

@@ -0,0 +1,85 @@
+diff --git a/packages/next/src/client/components/app-router-instance.ts b/packages/next/src/client/components/app-router-instance.ts
+index 420720a3cd..21a63aa2eb 100644
+--- a/packages/next/src/client/components/app-router-instance.ts
++++ b/packages/next/src/client/components/app-router-instance.ts
+@@ -67,26 +67,31 @@ export type ActionQueueNode = {
+ 
+ function runRemainingActions(
+   actionQueue: AppRouterActionQueue,
++  settledAction: ActionQueueNode,
+   setState: DispatchStatePromise
+ ) {
+-  if (actionQueue.pending !== null) {
+-    actionQueue.pending = actionQueue.pending.next
++  // Only advance the queue if the settled action is still at its head. If a
++  // navigation discarded this action, the navigation took its place and is
++  // still in flight — starting the next queued action now would run it
++  // against router state that doesn't include the navigation yet.
++  if (actionQueue.pending === settledAction) {
++    actionQueue.pending = settledAction.next
+     if (actionQueue.pending !== null) {
+       runAction({
+         actionQueue,
+         action: actionQueue.pending,
+         setState,
+       })
+-    }
+-  } else {
+-    // Check for refresh when pending is already null
+-    // This handles the case where a discarded server action completes
+-    // after the navigation has already finished and the queue is empty
+-    if (actionQueue.needsRefresh) {
+-      actionQueue.needsRefresh = false
+-      actionQueue.dispatch({ type: ACTION_REFRESH }, setState)
++      return
+     }
+   }
++
++  if (actionQueue.pending === null && actionQueue.needsRefresh) {
++    // The queue is idle; flush the refresh requested by a discarded server
++    // action that revalidated data.
++    actionQueue.needsRefresh = false
++    actionQueue.dispatch({ type: ACTION_REFRESH }, setState)
++  }
+ }
+ 
+ async function runAction({
+@@ -117,22 +122,22 @@ async function runAction({
+         // mark that we need to refresh after all actions complete
+         actionQueue.needsRefresh = true
+       }
+-      // Still need to run remaining actions even for discarded actions
+-      // to potentially trigger the refresh
+-      runRemainingActions(actionQueue, setState)
++      // This can't advance the queue (this action is no longer its head), but
++      // if the queue has already drained, it flushes the refresh now.
++      runRemainingActions(actionQueue, action, setState)
+       return
+     }
+ 
+     actionQueue.state = nextState
+ 
+-    runRemainingActions(actionQueue, setState)
++    runRemainingActions(actionQueue, action, setState)
+     action.resolve(nextState)
+   }
+ 
+   // if the action is a promise, set up a callback to resolve it
+   if (isThenable(actionResult)) {
+     actionResult.then(handleResult, (err) => {
+-      runRemainingActions(actionQueue, setState)
++      runRemainingActions(actionQueue, action, setState)
+       action.reject(err)
+     })
+   } else {
+@@ -197,6 +202,10 @@ function dispatchAction(
+     // (Note that it can't contain any earlier navigations, because we always put those into `actionQueue.pending` by calling `runAction`)
+     newAction.next = actionQueue.pending.next
+ 
++    if (actionQueue.last === actionQueue.pending) {
++      actionQueue.last = newAction
++    }
++
+     runAction({
+       actionQueue,
+       action: newAction,

nextjs-navigation-server-action-in-flight/solution/solve.sh

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

nextjs-navigation-server-action-in-flight/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 && pnpm exec playwright install --with-deps --only-shell 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-navigation-server-action-in-flight/tests/test.patch

@@ -0,0 +1,385 @@
+diff --git a/test/e2e/app-dir/actions-discarded-navigation-revert/actions-discarded-navigation-revert.test.ts b/test/e2e/app-dir/actions-discarded-navigation-revert/actions-discarded-navigation-revert.test.ts
+new file mode 100644
+index 00000000..bf1b09fa
+--- /dev/null
++++ b/test/e2e/app-dir/actions-discarded-navigation-revert/actions-discarded-navigation-revert.test.ts
+@@ -0,0 +1,167 @@
++import { nextTestSetup } from 'e2e-utils'
++import type * as Playwright from 'playwright'
++import { createRouterAct } from 'router-act'
++
++describe('discarded action settling while a navigation is pending (#86151)', () => {
++  const { next } = nextTestSetup({ files: __dirname })
++
++  // Navigating while a server action is in flight discards that action:
++  // its result is never applied. These tests cover the window where the
++  // discarded action's response arrives while the navigation is still
++  // ongoing. The navigation must not be reverted, and later actions must
++  // not run until it finishes — if one ran earlier, it would see the
++  // pre-navigation page and undo the navigation.
++  async function interleave(
++    dispatchButton: string,
++    options?: { allowErrorStatusCodes: number[] }
++  ) {
++    let page: Playwright.Page
++    const browser = await next.browser('/', {
++      beforePageLoad(p: Playwright.Page) {
++        page = p
++      },
++    })
++    const act = createRouterAct(page, options)
++
++    // data-render counts how many times the client received new data for
++    // the root layout. Navigations preserve the root layout, so it only
++    // changes when the router refreshes.
++    const initialRender = await browser
++      .elementById('stamp')
++      .getAttribute('data-render')
++
++    await act(
++      async () => {
++        // Start server action A. Its response is withheld, so it stays in
++        // flight throughout this scope.
++        await act(async () => {
++          await browser.elementById(dispatchButton).click()
++        }, 'block')
++
++        // Start server action B. Actions run one at a time, so B waits for
++        // A and no request is issued yet.
++        await act(async () => {
++          await browser.elementById('dispatch-b').click()
++        }, 'no-requests')
++
++        // Navigate before A or B finished. This discards A. The navigation
++        // response is withheld too, so the navigation is still ongoing when
++        // A's response arrives below.
++        await act(
++          async () => {
++            await browser.elementById('go-dest').click()
++          },
++          { includes: 'Destination page', block: true }
++        )
++
++        // Exiting this scope delivers the withheld responses in the same
++        // order: first A's, mid-navigation — the moment under test — then
++        // the navigation's. Only then may B run.
++      },
++      // B ran and completed.
++      { includes: 'b-result' }
++    )
++
++    // B completing means all three operations have settled.
++    await browser.waitForElementByCss('#status-b[data-status="b-result"]')
++
++    // If B ran too early, it saw the pre-navigation page — but that is not
++    // necessarily visible yet. Running one more action makes it visible:
++    // with the bug, the URL flips back to "/" here instead of staying
++    // on /dest.
++    await act(
++      async () => {
++        await browser.elementById('dispatch-c').click()
++      },
++      { includes: 'c-result' }
++    )
++    await browser.waitForElementByCss('#status-c[data-status="c-result"]')
++
++    expect(new URL(await browser.url()).pathname).toBe('/dest')
++    expect(await browser.elementById('dest').text()).toBe('Destination page')
++
++    return { browser, initialRender }
++  }
++
++  it('keeps the navigation when the discarded action resolves', async () => {
++    const { browser, initialRender } = await interleave('dispatch-resolve')
++
++    // The discarded action didn't revalidate anything, so there must be
++    // no refresh.
++    expect(await browser.elementById('stamp').getAttribute('data-render')).toBe(
++      initialRender
++    )
++  })
++
++  // Same scenario, but the discarded action fails. Failure is handled
++  // separately from success, so cover both.
++  it('keeps the navigation when the discarded action rejects', async () => {
++    const { browser, initialRender } = await interleave('dispatch-reject', {
++      // A server action that throws responds with a 500.
++      allowErrorStatusCodes: [500],
++    })
++
++    await browser.waitForElementByCss('#status-a[data-status="rejected"]')
++    expect(await browser.elementById('stamp').getAttribute('data-render')).toBe(
++      initialRender
++    )
++  })
++
++  // An action can also be dispatched *while* the navigation is ongoing.
++  // It must run once the navigation finishes. (At one point it never ran:
++  // its caller never settled, and the router stopped applying updates
++  // entirely — the URL never even changed to the navigation target.)
++  it('runs an action dispatched during the navigation once it finishes', async () => {
++    let page: Playwright.Page
++    const browser = await next.browser('/', {
++      beforePageLoad(p: Playwright.Page) {
++        page = p
++      },
++    })
++    const act = createRouterAct(page)
++
++    await act(
++      async () => {
++        // Start server action A. Its response is withheld, so it stays in
++        // flight throughout this scope.
++        await act(async () => {
++          await browser.elementById('dispatch-resolve').click()
++        }, 'block')
++
++        // Navigate before A finished. This discards A. The navigation
++        // response is withheld too, so the navigation is still ongoing
++        // when B is dispatched below.
++        await act(
++          async () => {
++            await browser.elementById('go-dest').click()
++          },
++          { includes: 'Destination page', block: true }
++        )
++
++        // Dispatch server action B while the navigation is ongoing. It
++        // must wait for the navigation, so no request is issued yet.
++        await act(async () => {
++          await browser.elementById('dispatch-b').click()
++        }, 'no-requests')
++      },
++      // B ran once the withheld responses were delivered.
++      { includes: 'b-result' }
++    )
++
++    await browser.waitForElementByCss('#status-b[data-status="b-result"]')
++    expect(new URL(await browser.url()).pathname).toBe('/dest')
++    expect(await browser.elementById('dest').text()).toBe('Destination page')
++  })
++
++  it('defers the refresh from a discarded revalidating action until the queue drains', async () => {
++    const { browser, initialRender } = await interleave('dispatch-revalidate')
++
++    // The discarded action revalidated, so a refresh must still happen —
++    // after everything else, and without undoing the navigation.
++    await browser.waitForElementByCss(
++      `#stamp:not([data-render="${initialRender}"])`
++    )
++    expect(new URL(await browser.url()).pathname).toBe('/dest')
++    expect(await browser.elementById('dest').text()).toBe('Destination page')
++  })
++})
+diff --git a/test/e2e/app-dir/actions-discarded-navigation-revert/app/actions.ts b/test/e2e/app-dir/actions-discarded-navigation-revert/app/actions.ts
+new file mode 100644
+index 00000000..eba7c318
+--- /dev/null
++++ b/test/e2e/app-dir/actions-discarded-navigation-revert/app/actions.ts
+@@ -0,0 +1,16 @@
++'use server'
++
++import { revalidatePath } from 'next/cache'
++
++export async function echo(value: string) {
++  return value
++}
++
++export async function reject() {
++  throw new Error('intentional test error')
++}
++
++export async function revalidate() {
++  revalidatePath('/', 'layout')
++  return 'revalidated'
++}
+diff --git a/test/e2e/app-dir/actions-discarded-navigation-revert/app/controls.tsx b/test/e2e/app-dir/actions-discarded-navigation-revert/app/controls.tsx
+new file mode 100644
+index 00000000..321086c5
+--- /dev/null
++++ b/test/e2e/app-dir/actions-discarded-navigation-revert/app/controls.tsx
+@@ -0,0 +1,91 @@
++'use client'
++
++import { useState } from 'react'
++import { useRouter } from 'next/navigation'
++import { echo, reject, revalidate } from './actions'
++
++// Rendered in the root layout so the statuses survive navigations.
++export function Controls() {
++  const router = useRouter()
++  const [a, setA] = useState('idle')
++  const [b, setB] = useState('idle')
++  const [c, setC] = useState('idle')
++
++  async function dispatchResolve() {
++    setA('pending')
++    try {
++      setA(await echo('a-result'))
++    } catch {
++      setA('rejected')
++    }
++  }
++
++  async function dispatchReject() {
++    setA('pending')
++    try {
++      await reject()
++      setA('resolved')
++    } catch {
++      setA('rejected')
++    }
++  }
++
++  async function dispatchRevalidate() {
++    setA('pending')
++    try {
++      setA(await revalidate())
++    } catch {
++      setA('rejected')
++    }
++  }
++
++  async function dispatchB() {
++    setB('pending')
++    try {
++      setB(await echo('b-result'))
++    } catch {
++      setB('rejected')
++    }
++  }
++
++  async function dispatchC() {
++    setC('pending')
++    try {
++      setC(await echo('c-result'))
++    } catch {
++      setC('rejected')
++    }
++  }
++
++  return (
++    <div>
++      <button id="dispatch-resolve" onClick={dispatchResolve}>
++        dispatch resolving action
++      </button>
++      <button id="dispatch-reject" onClick={dispatchReject}>
++        dispatch rejecting action
++      </button>
++      <button id="dispatch-revalidate" onClick={dispatchRevalidate}>
++        dispatch revalidating action
++      </button>
++      <button id="dispatch-b" onClick={dispatchB}>
++        dispatch queued action
++      </button>
++      <button id="go-dest" onClick={() => router.push('/dest')}>
++        go to destination
++      </button>
++      <button id="dispatch-c" onClick={dispatchC}>
++        dispatch probe action
++      </button>
++      <div id="status-a" data-status={a}>
++        a:{a}
++      </div>
++      <div id="status-b" data-status={b}>
++        b:{b}
++      </div>
++      <div id="status-c" data-status={c}>
++        c:{c}
++      </div>
++    </div>
++  )
++}
+diff --git a/test/e2e/app-dir/actions-discarded-navigation-revert/app/dest/page.tsx b/test/e2e/app-dir/actions-discarded-navigation-revert/app/dest/page.tsx
+new file mode 100644
+index 00000000..f40f1e5e
+--- /dev/null
++++ b/test/e2e/app-dir/actions-discarded-navigation-revert/app/dest/page.tsx
+@@ -0,0 +1,17 @@
++import { Suspense } from 'react'
++import { connection } from 'next/server'
++
++// connection() makes the page dynamic in all modes, so navigating here
++// always produces a router request.
++async function Content() {
++  await connection()
++  return <div id="dest">Destination page</div>
++}
++
++export default function DestPage() {
++  return (
++    <Suspense fallback={null}>
++      <Content />
++    </Suspense>
++  )
++}
+diff --git a/test/e2e/app-dir/actions-discarded-navigation-revert/app/layout.tsx b/test/e2e/app-dir/actions-discarded-navigation-revert/app/layout.tsx
+new file mode 100644
+index 00000000..f387ca61
+--- /dev/null
++++ b/test/e2e/app-dir/actions-discarded-navigation-revert/app/layout.tsx
+@@ -0,0 +1,29 @@
++import { Suspense } from 'react'
++import { connection } from 'next/server'
++import { Controls } from './controls'
++import { RenderCounter } from './render-counter'
++
++// The stamp only changes when the router refreshes: navigations preserve the
++// root layout, so a new stamp on the client means a refresh happened.
++async function Stamp() {
++  await connection()
++  return <RenderCounter uuid={crypto.randomUUID()} />
++}
++
++export default function RootLayout({
++  children,
++}: {
++  children: React.ReactNode
++}) {
++  return (
++    <html lang="en">
++      <body>
++        <Suspense fallback={null}>
++          <Stamp />
++        </Suspense>
++        <Controls />
++        {children}
++      </body>
++    </html>
++  )
++}
+diff --git a/test/e2e/app-dir/actions-discarded-navigation-revert/app/page.tsx b/test/e2e/app-dir/actions-discarded-navigation-revert/app/page.tsx
+new file mode 100644
+index 00000000..3e134694
+--- /dev/null
++++ b/test/e2e/app-dir/actions-discarded-navigation-revert/app/page.tsx
+@@ -0,0 +1,3 @@
++export default function Page() {
++  return <div id="origin">Origin page</div>
++}
+diff --git a/test/e2e/app-dir/actions-discarded-navigation-revert/app/render-counter.tsx b/test/e2e/app-dir/actions-discarded-navigation-revert/app/render-counter.tsx
+new file mode 100644
+index 00000000..7909f06b
+--- /dev/null
++++ b/test/e2e/app-dir/actions-discarded-navigation-revert/app/render-counter.tsx
+@@ -0,0 +1,20 @@
++'use client'
++
++import { useState } from 'react'
++
++// Counts how many times the client received new dynamic data for the root
++// layout. The count lives in client state: a server-side counter would break
++// in deploy tests, where the server is stateless.
++export function RenderCounter({ uuid }: { uuid: string }) {
++  const [count, setCount] = useState(0)
++  const [prevUuid, setPrevUuid] = useState(uuid)
++  if (prevUuid !== uuid) {
++    setPrevUuid(uuid)
++    setCount(count + 1)
++  }
++  return (
++    <div id="stamp" data-render={count}>
++      renders:{count}
++    </div>
++  )
++}