Fix prerendering of interception routes with generateStaticParams (vercel#85835)

## What

Fixes a bug where interception routes in parallel slots could not be
prerendered using `generateStaticParams`, causing 404 responses when
these routes were accessed directly.

## Why

**The Problem:**

Interception routes like `app/@modal/(.)photo/[id]/page.tsx` could not
be prerendered even when they exported `generateStaticParams`. This was
because the static path generation code only examined "children"
segments in the loader tree, completely missing segments from parallel
routes (like `@modal`) that actually contribute to the pathname.

**Root Cause:**

The previous implementation used `childrenRouteParamSegments` which only
traversed the `children` branch of the loader tree:

```typescript
// OLD: Only looked at children
const childrenRouteParamSegments = [...segments from children only...]

// This missed parallel routes like @modal that have dynamic segments
```

For a route structure like:
```
app/
  [username]/
    page.tsx
  @modal/
    (.)[username]/
      [id]/
        page.tsx  // ← This route's segments were MISSED
```

The build system couldn't discover the `[id]` parameter in the parallel
route because it never traversed that branch of the tree.

## How

**Solution:**

Introduces `extractPathnameSegments()` which properly traverses the
ENTIRE loader tree (not just children) to find ALL segments that
contribute to the pathname:

1. **BFS Traversal**: Explores both `children` AND all parallel route
slots (e.g., `@modal`, `@sidebar`)

2. **Depth Tracking**: Correctly tracks URL depth by:
   - Skipping route groups `(marketing)` - not in URL
   - Skipping parallel markers `@modal` - not in URL
   - Including interception markers `(.)photo` - ARE in URL

3. **Prefix Validation**: Ensures static segments match the target
pathname before including dynamic segments

4. **Complete Parameter Discovery**: Returns all segments that
contribute to pathname construction, regardless of which tree branch
they're in

**Example:**

For `app/@modal/(.)photo/[id]/page.tsx`:
- Old: Missed the `[id]` parameter entirely
- New: Discovers `[id]` and enables prerendering with
`generateStaticParams`

## Changes

**New Module**: `extract-pathname-segments.ts` (192 lines)
- Core algorithm for traversing loader tree and extracting pathname
segments
- Handles complex cases: parallel routes, interception routes, route
groups
- Well-documented with examples and algorithm explanation

**Comprehensive Tests**: `extract-pathname-segments.test.ts` (897 lines)
- Tests for simple cases, nested structures, parallel routes
- Interception route handling in various configurations
- Route group behavior and edge cases
- Depth tracking validation

**Integration**: `static-paths/app.ts`
- Replaced `childrenRouteParamSegments` with `extractPathnameSegments()`
- Updated pathname construction to use segments from parallel routes
- Maintained backward compatibility

**E2E Test**: Added test validating prerendering works for intercepted
routes

## Test Plan

The new E2E test verifies:
```typescript
it('should prerender a dynamic intercepted route', async () => {
  // Verifies build output contains the prerendered interception route
  expect(next.cliOutput).toContain('/(.)john/1')
  // Verifies it doesn't generate the non-intercepted path
  expect(next.cliOutput).not.toContain('/john/1')
})
```

## Impact

**Before**: Interception routes with dynamic segments returned 404 when
accessed directly, even with `generateStaticParams`

**After**: These routes are properly prerendered at build time and
return correct responses

Author: wyattjoh

packages/next/errors.json

@@ -927,5 +927,8 @@
   "926": "Optional route parameters are not yet supported (\"[%s]\") in route \"%s\".",
   "927": "No debug targets found",
   "928": "Unable to get server address",
-  "929": "No pages or app directory found."
+  "929": "No pages or app directory found.",
+  "930": "Expected a dynamic route, but got a static route: %s",
+  "931": "Unexpected empty path segments match for a route \"%s\" with param \"%s\" of type \"%s\"",
+  "932": "Could not resolve param value for segment: %s"
 }

packages/next/src/build/segment-config/app/app-segments.ts

@@ -17,9 +17,6 @@ import {
   getLayoutOrPageModule,
   type LoaderTree,
 } from '../../../server/lib/app-dir-module'
-import { PAGE_SEGMENT_KEY } from '../../../shared/lib/segment'
-import type { FallbackRouteParam } from '../../static-paths/types'
-import { createFallbackRouteParam } from '../../static-paths/utils'
 import type { DynamicParamTypes } from '../../../shared/lib/app-router-types'
 
 type GenerateStaticParams = (options: { params?: Params }) => Promise<Params[]>
@@ -63,14 +60,7 @@ export type AppSegment = {
   paramType: DynamicParamTypes | undefined
   filePath: string | undefined
   config: AppSegmentConfig | undefined
-  isDynamicSegment: boolean
   generateStaticParams: GenerateStaticParams | undefined
-
-  /**
-   * Whether this segment is a parallel route segment or descends from a
-   * parallel route segment.
-   */
-  isParallelRouteSegment: boolean | undefined
 }
 
 /**
@@ -82,79 +72,57 @@ export type AppSegment = {
 async function collectAppPageSegments(routeModule: AppPageRouteModule) {
   // We keep track of unique segments, since with parallel routes, it's possible
   // to see the same segment multiple times.
-  const uniqueSegments = new Map<string, AppSegment>()
+  const segments: AppSegment[] = []
 
-  // Queue will store tuples of [loaderTree, currentSegments, isParallelRouteSegment]
-  type QueueItem = [
-    loaderTree: LoaderTree,
-    currentSegments: AppSegment[],
-    isParallelRouteSegment: boolean,
-  ]
-  const queue: QueueItem[] = [[routeModule.userland.loaderTree, [], false]]
+  // Queue will store loader trees.
+  const queue: LoaderTree[] = [routeModule.userland.loaderTree]
 
   while (queue.length > 0) {
-    const [loaderTree, currentSegments, isParallelRouteSegment] = queue.shift()!
+    const loaderTree = queue.shift()!
     const [name, parallelRoutes] = loaderTree
 
     // Process current node
     const { mod: userland, filePath } = await getLayoutOrPageModule(loaderTree)
     const isClientComponent = userland && isClientReference(userland)
 
-    const { param: paramName, type: paramType } = getSegmentParam(name) ?? {}
+    const param = getSegmentParam(name)
 
     const segment: AppSegment = {
       name,
-      paramName,
-      paramType,
+      paramName: param?.paramName,
+      paramType: param?.paramType,
       filePath,
       config: undefined,
-      isDynamicSegment: !!paramName,
       generateStaticParams: undefined,
-      isParallelRouteSegment,
     }
 
     // Only server components can have app segment configurations
     if (!isClientComponent) {
       attach(segment, userland, routeModule.definition.pathname)
     }
 
-    // Create a unique key for the segment
-    const segmentKey = getSegmentKey(segment)
-    if (!uniqueSegments.has(segmentKey)) {
-      uniqueSegments.set(segmentKey, segment)
-    }
-
-    const updatedSegments = [...currentSegments, segment]
-
-    // If this is a page segment, we've reached a leaf node
-    if (name === PAGE_SEGMENT_KEY) {
-      // Add all segments in the current path, preferring non-parallel segments
-      updatedSegments.forEach((seg) => {
-        const key = getSegmentKey(seg)
-        if (!uniqueSegments.has(key)) {
-          uniqueSegments.set(key, seg)
-        }
-      })
+    // If this segment doesn't already exist, then add it to the segments array.
+    // The list of segments is short so we just use a list traversal to check
+    // for duplicates and spare us needing to maintain the string key.
+    if (
+      segments.every(
+        (s) =>
+          s.name !== segment.name ||
+          s.paramName !== segment.paramName ||
+          s.paramType !== segment.paramType ||
+          s.filePath !== segment.filePath
+      )
+    ) {
+      segments.push(segment)
     }
 
     // Add all parallel routes to the queue
-    for (const parallelRouteKey in parallelRoutes) {
-      const parallelRoute = parallelRoutes[parallelRouteKey]
-      queue.push([
-        parallelRoute,
-        updatedSegments,
-        // A parallel route segment is one that descends from a segment that is
-        // not children or descends from a parallel route segment.
-        isParallelRouteSegment || parallelRouteKey !== 'children',
-      ])
+    for (const parallelRoute of Object.values(parallelRoutes)) {
+      queue.push(parallelRoute)
     }
   }
 
-  return Array.from(uniqueSegments.values())
-}
-
-function getSegmentKey(segment: AppSegment) {
-  return `${segment.name}-${segment.filePath ?? ''}-${segment.paramName ?? ''}-${segment.isParallelRouteSegment ? 'pr' : 'np'}`
+  return segments
 }
 
 /**
@@ -174,17 +142,15 @@ function collectAppRouteSegments(
 
   // Generate all the segments.
   const segments: AppSegment[] = parts.map((name) => {
-    const { param: paramName, type: paramType } = getSegmentParam(name) ?? {}
+    const param = getSegmentParam(name)
 
     return {
       name,
-      paramName,
-      paramType,
+      paramName: param?.paramName,
+      paramType: param?.paramType,
       filePath: undefined,
-      isDynamicSegment: !!paramName,
       config: undefined,
       generateStaticParams: undefined,
-      isParallelRouteSegment: undefined,
     } satisfies AppSegment
   })
 
@@ -221,55 +187,3 @@ export function collectSegments(
     'Expected a route module to be one of app route or page'
   )
 }
-
-/**
- * Collects the fallback route params for a given app page route module. This is
- * a variant of the `collectSegments` function that only collects the fallback
- * route params without importing anything.
- *
- * @param routeModule the app page route module
- * @returns the fallback route params for the app page route module
- */
-export function collectFallbackRouteParams(
-  routeModule: AppPageRouteModule
-): readonly FallbackRouteParam[] {
-  const uniqueSegments = new Map<string, FallbackRouteParam>()
-
-  // Queue will store tuples of [loaderTree, isParallelRouteSegment]
-  type QueueItem = [loaderTree: LoaderTree, isParallelRouteSegment: boolean]
-  const queue: QueueItem[] = [[routeModule.userland.loaderTree, false]]
-
-  while (queue.length > 0) {
-    const [loaderTree, isParallelRouteSegment] = queue.shift()!
-    const [name, parallelRoutes] = loaderTree
-
-    // Handle this segment (if it's a dynamic segment param).
-    const segmentParam = getSegmentParam(name)
-    if (segmentParam) {
-      const key = `${name}-${segmentParam.param}-${isParallelRouteSegment ? 'pr' : 'np'}`
-      if (!uniqueSegments.has(key)) {
-        uniqueSegments.set(
-          key,
-          createFallbackRouteParam(
-            segmentParam.param,
-            segmentParam.type,
-            isParallelRouteSegment
-          )
-        )
-      }
-    }
-
-    // Add all of this segment's parallel routes to the queue.
-    for (const parallelRouteKey in parallelRoutes) {
-      const parallelRoute = parallelRoutes[parallelRouteKey]
-      queue.push([
-        parallelRoute,
-        // A parallel route segment is one that descends from a segment that is
-        // not children or descends from a parallel route segment.
-        isParallelRouteSegment || parallelRouteKey !== 'children',
-      ])
-    }
-  }
-
-  return Array.from(uniqueSegments.values())
-}

packages/next/src/build/segment-config/app/collect-root-param-keys.ts

@@ -17,9 +17,9 @@ function collectAppPageRootParamKeys(
     const [name, parallelRoutes, modules] = current
 
     // If this is a dynamic segment, then we collect the param.
-    const param = getSegmentParam(name)?.param
-    if (param) {
-      rootParams.push(param)
+    const paramName = getSegmentParam(name)?.paramName
+    if (paramName) {
+      rootParams.push(paramName)
     }
 
     // If this has a layout module, then we've found the root layout because