next 16.0.1-canary.1 → 16.0.1-canary.2

package/dist/bin/next

@@ -79,7 +79,7 @@ const program = new NextRootCommand();
 program.name('next').description('The Next.js CLI allows you to develop, build, start your application, and more.').configureHelp({
     formatHelp: (cmd, helper)=>(0, _formatclihelpoutput.formatCliHelpOutput)(cmd, helper),
     subcommandTerm: (cmd)=>`${cmd.name()} ${cmd.usage()}`
-}).helpCommand(false).helpOption('-h, --help', 'Displays this message.').version(`Next.js v${"16.0.1-canary.1"}`, '-v, --version', 'Outputs the Next.js version.');
+}).helpCommand(false).helpOption('-h, --help', 'Displays this message.').version(`Next.js v${"16.0.1-canary.2"}`, '-v, --version', 'Outputs the Next.js version.');
 program.command('build').description('Creates an optimized production build of your application. The output displays information about each route.').argument('[directory]', `A directory on which to build the application. ${(0, _picocolors.italic)('If no directory is provided, the current directory will be used.')}`).option('-d, --debug', 'Enables a more verbose build output.').option('--debug-prerender', 'Enables debug mode for prerendering. Not for production use!').option('--no-mangling', 'Disables mangling.').option('--profile', 'Enables production profiling for React.').option('--experimental-app-only', 'Builds only App Router routes.').option('--turbo', 'Builds using Turbopack.').option('--turbopack', 'Builds using Turbopack.').option('--webpack', 'Builds using webpack.').addOption(new _commander.Option('--experimental-build-mode [mode]', 'Uses an experimental build mode.').choices([
     'compile',
     'generate',

package/dist/build/index.js

@@ -375,7 +375,7 @@ async function build(dir, reactProductionProfiling = false, debugOutput = false,
     try {
         const nextBuildSpan = (0, _trace.trace)('next-build', undefined, {
             buildMode: experimentalBuildMode,
-            version: "16.0.1-canary.1"
+            version: "16.0.1-canary.2"
         });
         _buildcontext.NextBuildContext.nextBuildSpan = nextBuildSpan;
         _buildcontext.NextBuildContext.dir = dir;
@@ -896,7 +896,7 @@ async function build(dir, reactProductionProfiling = false, debugOutput = false,
             // Files outside of the distDir can be "type": "module"
             await writeFileUtf8(_path.default.join(distDir, 'package.json'), '{"type": "commonjs"}');
             // These are written to distDir, so they need to come after creating and cleaning distDr.
-            await (0, _builddiagnostics.recordFrameworkVersion)("16.0.1-canary.1");
+            await (0, _builddiagnostics.recordFrameworkVersion)("16.0.1-canary.2");
             await (0, _builddiagnostics.updateBuildDiagnostics)({
                 buildStage: 'start'
             });
@@ -2573,7 +2573,7 @@ async function build(dir, reactProductionProfiling = false, debugOutput = false,
                         configOutDir: _path.default.join(dir, configOutDir),
                         staticPages,
                         serverPropsPages,
-                        nextVersion: "16.0.1-canary.1",
+                        nextVersion: "16.0.1-canary.2",
                         tracingRoot: outputFileTracingRoot,
                         hasNodeMiddleware,
                         hasInstrumentationHook,

package/dist/build/static-paths/app.d.ts

@@ -4,9 +4,10 @@ import type { AppSegment } from '../segment-config/app/app-segments';
 import type { FallbackRouteParam, PrerenderedRoute, StaticPathsResult } from './types';
 import { FallbackMode } from '../../lib/fallback';
 import type { IncrementalCache } from '../../server/lib/incremental-cache';
+import type { LoaderTree } from '../../server/lib/app-dir-module';
 import type { NextConfigComplete } from '../../server/config-shared';
 import type { WorkStore } from '../../server/app-render/work-async-storage.external';
-import type { DynamicParamTypes } from '../../shared/lib/app-router-types';
+import type { AppRouteModule } from '../../server/route-modules/app-route/module.compiled';
 /**
  * Filters out duplicate parameters from a list of parameters.
  * This function uses a Map to efficiently store and retrieve unique parameter combinations.
@@ -90,20 +91,20 @@ export declare function assignErrorIfEmpty(prerenderedRoutes: readonly Prerender
     readonly paramName: string;
 }>): void;
 /**
- * Resolves parallel route parameters from regular route parameters. This function
- * handles the complex logic of determining how to populate parallel route params
- * based on their type (catchall, optional-catchall, or regular) and the current
- * state of fallback parameters.
+ * Resolves parallel route parameters from the loader tree. This function uses
+ * tree-based traversal to correctly handle the hierarchical structure of parallel
+ * routes and accurately determine parameter values based on their depth in the tree.
  *
- * @param parallelRouteSegments - Array of parallel route segments with their types and param names
+ * Unlike interpolateParallelRouteParams (which has a complete URL at runtime),
+ * this build-time function determines which parallel route params are unknown.
+ * The pathname may contain placeholders like [slug], making it incomplete.
+ *
+ * @param loaderTree - The loader tree structure containing route hierarchy
  * @param params - The current route parameters object (will be mutated)
- * @param pathname - The current pathname being processed
+ * @param pathname - The current pathname being processed (may contain placeholders)
  * @param fallbackRouteParams - Array of fallback route parameters (will be mutated)
  */
-export declare function resolveParallelRouteParams(parallelRouteSegments: ReadonlyArray<{
-    readonly paramName: string;
-    readonly paramType: DynamicParamTypes;
-}>, params: Params, pathname: string, fallbackRouteParams: FallbackRouteParam[]): void;
+export declare function resolveParallelRouteParams(loaderTree: LoaderTree, params: Params, pathname: string, fallbackRouteParams: FallbackRouteParam[]): void;
 /**
  * Processes app directory segments to build route parameters from generateStaticParams functions.
  * This function walks through the segments array and calls generateStaticParams for each segment that has it,
@@ -138,7 +139,7 @@ export declare function buildAppStaticPaths({ dir, page, distDir, cacheComponent
     cacheMaxMemorySize: number;
     requestHeaders: IncrementalCache['requestHeaders'];
     nextConfigOutput: 'standalone' | 'export' | undefined;
-    ComponentMod: AppPageModule;
+    ComponentMod: AppPageModule | AppRouteModule;
     isRoutePPREnabled: boolean;
     buildId: string;
     rootParamKeys: readonly string[];

package/dist/build/static-paths/app.js

@@ -49,6 +49,8 @@ const _escapepathdelimiters = /*#__PURE__*/ _interop_require_default(require("..
 const _createincrementalcache = require("../../export/helpers/create-incremental-cache");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
+const _parseloadertree = require("../../shared/lib/router/utils/parse-loader-tree");
+const _interceptionroutes = require("../../shared/lib/router/utils/interception-routes");
 const _emptygeneratestaticparamserror = require("../../shared/lib/errors/empty-generate-static-params-error");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -404,55 +406,119 @@ function assignErrorIfEmpty(prerenderedRoutes, childrenRouteParams) {
         }
     }
 }
-function resolveParallelRouteParams(parallelRouteSegments, params, pathname, fallbackRouteParams) {
-    // Resolve parallel route params from the regular route params
-    for (const { paramType, paramName } of parallelRouteSegments){
-        // Check if we can resolve this from existing params
-        if (params[paramName]) {
-            continue;
+function resolveParallelRouteParams(loaderTree, params, pathname, fallbackRouteParams) {
+    // Stack-based traversal with depth and parallel route key tracking
+    const stack = [
+        {
+            tree: loaderTree,
+            depth: 0,
+            parallelKey: 'children'
         }
-        if (paramType === 'catchall' || paramType === 'optional-catchall') {
-            // If there are any fallback route segments then we can't use the
-            // pathname to derive the value because it's not complete. We can
-            // make this assumption because the routes are always resolved left
-            // to right and the catchall is always the last segment, so any
-            // route parameters that are unknown will always contribute to the
-            // pathname and therefore the catchall param too.
-            if (fallbackRouteParams.some((param)=>!param.isParallelRouteParam)) {
-                fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
-                continue;
-            }
-            // For catchall routes in parallel segments, derive from pathname
-            // Similar to getDynamicParam's pagePath parsing logic
-            const pathSegments = pathname.split('/').filter(Boolean);
-            // For catchall parallel routes, we use the full path segments
-            // This mimics the behavior in getDynamicParam where the pagePath
-            // is split and used to populate catchall values
-            if (pathSegments.length > 0) {
-                // FIXME: (NAR-335) this should handle prefixed segments
-                params[paramName] = pathSegments;
-            } else if (paramType === 'optional-catchall') {
-                params[paramName] = [];
-            } else {
-                // We shouldn't be able to match a catchall segment without any path
-                // segments if it's not an optional catchall.
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a pathname "${pathname}" with param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
-                    value: "E792",
-                    enumerable: false,
-                    configurable: true
-                });
+    ];
+    // Parse pathname into segments for depth-based resolution
+    const pathSegments = pathname.split('/').filter(Boolean);
+    while(stack.length > 0){
+        const { tree, depth, parallelKey } = stack.pop();
+        const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+        // Only process segments that are in parallel routes (not the main 'children' route)
+        if (parallelKey !== 'children') {
+            const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
+            if (segmentParam && !params.hasOwnProperty(segmentParam.param)) {
+                const { param: paramName, type: paramType } = segmentParam;
+                switch(paramType){
+                    case 'catchall':
+                    case 'optional-catchall':
+                    case 'catchall-intercepted':
+                        // If there are any non-parallel fallback route segments, we can't use the
+                        // pathname to derive the value because it's not complete. We can make
+                        // this assumption because routes are resolved left to right.
+                        if (fallbackRouteParams.some((param)=>!param.isParallelRouteParam)) {
+                            fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
+                            break;
+                        }
+                        // For catchall routes in parallel segments, derive from pathname
+                        // using depth to determine which segments to use
+                        const remainingSegments = pathSegments.slice(depth);
+                        // Process segments to handle any embedded dynamic params
+                        // Track if we encounter any unknown param placeholders
+                        let hasUnknownParam = false;
+                        const processedSegments = remainingSegments.flatMap((pathSegment)=>{
+                            const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+                            if (param) {
+                                // If the segment is a param placeholder, check if we have its value
+                                if (!params.hasOwnProperty(param.param)) {
+                                    // Unknown param placeholder in pathname - can't derive full value
+                                    hasUnknownParam = true;
+                                    return undefined;
+                                }
+                                // If the segment matches a param, return the param value
+                                // We don't encode values here as that's handled during retrieval.
+                                return params[param.param];
+                            }
+                            // Otherwise it's a static segment
+                            return pathSegment;
+                        }).filter((s)=>s !== undefined);
+                        // If we encountered any unknown param placeholders, we can't derive
+                        // the full catch-all value from the pathname, so mark as fallback.
+                        if (hasUnknownParam) {
+                            fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
+                            break;
+                        }
+                        if (processedSegments.length > 0) {
+                            params[paramName] = processedSegments;
+                        } else if (paramType === 'optional-catchall') {
+                            params[paramName] = [];
+                        } else {
+                            // We shouldn't be able to match a catchall segment without any path
+                            // segments if it's not an optional catchall
+                            throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a pathname "${pathname}" with param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
+                                value: "E792",
+                                enumerable: false,
+                                configurable: true
+                            });
+                        }
+                        break;
+                    case 'dynamic':
+                    case 'dynamic-intercepted':
+                        // For regular dynamic parameters, take the segment at this depth
+                        if (depth < pathSegments.length) {
+                            const pathSegment = pathSegments[depth];
+                            const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+                            // Check if the segment at this depth is a placeholder for an unknown param
+                            if (param && !params.hasOwnProperty(param.param)) {
+                                // The segment is a placeholder like [category] and we don't have the value
+                                fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
+                                break;
+                            }
+                            // If the segment matches a param, use the param value from params object
+                            // Otherwise it's a static segment, just use it directly
+                            // We don't encode values here as that's handled during retrieval
+                            params[paramName] = param ? params[param.param] : pathSegment;
+                        } else {
+                            // No segment at this depth, mark as fallback.
+                            fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
+                        }
+                        break;
+                    default:
+                        paramType;
+                }
             }
-        } else if (paramType === 'dynamic') {
-            // We can't resolve dynamic param values at build time because they're
-            // inferred from the request pathname.
-            fallbackRouteParams.push((0, _utils.createFallbackRouteParam)(paramName, paramType, true));
-        } else {
-            // This is some other type of route param that shouldn't get resolved
-            // statically.
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected match for a pathname "${pathname}" with a param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
-                value: "E791",
-                enumerable: false,
-                configurable: true
+        }
+        // Calculate next depth - increment if this is not a route group and not empty
+        let nextDepth = depth;
+        // Route groups are like (marketing) or (dashboard), NOT interception routes like (.)photo
+        // Interception routes start with markers like (.), (..), (...), (..)(..)) and should increment depth
+        const isInterceptionRoute = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((marker)=>segment.startsWith(marker));
+        const isRouteGroup = !isInterceptionRoute && segment.startsWith('(') && segment.endsWith(')');
+        if (!isRouteGroup && segment !== '') {
+            nextDepth++;
+        }
+        // Add all parallel routes to the stack for processing.
+        for (const [key, route] of Object.entries(parallelRoutes)){
+            stack.push({
+                tree: route,
+                depth: nextDepth,
+                parallelKey: key
             });
         }
     }
@@ -552,7 +618,6 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
         cacheMaxMemorySize
     });
     const childrenRouteParamSegments = [];
-    const parallelRouteSegments = [];
     // These are all the parallel fallback route params that will be included when
     // we're emitting the route for the base route.
     const parallelFallbackRouteParams = [];
@@ -576,13 +641,9 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
             if (nonParallelParamNames.has(segment.paramName)) {
                 continue;
             }
-            // Collect all the parallel route segments that have dynamic params for
-            // second-pass resolution.
-            parallelRouteSegments.push({
-                name: segment.name,
-                paramName: segment.paramName,
-                paramType: segment.paramType
-            });
+            // Collect parallel fallback route params for the base route.
+            // The actual parallel route param resolution is now handled by
+            // resolveParallelRouteParams using the loader tree.
             parallelFallbackRouteParams.push((0, _utils.createFallbackRouteParam)(segment.paramName, segment.paramType, true));
         } else {
             // Collect all the route param keys that are not parallel route params.
@@ -712,8 +773,11 @@ async function buildAppStaticPaths({ dir, page, distDir, cacheComponents, authIn
                 pathname = pathname.replace(segment.name, (0, _utils.encodeParam)(paramValue, (value)=>(0, _escapepathdelimiters.default)(value, true)));
                 encodedPathname = encodedPathname.replace(segment.name, (0, _utils.encodeParam)(paramValue, encodeURIComponent));
             }
-            // Resolve parallel route params from the regular route params
-            resolveParallelRouteParams(parallelRouteSegments, params, pathname, fallbackRouteParams);
+            // Resolve parallel route params from the loader tree if this is from an
+            // app page.
+            if ('loaderTree' in ComponentMod.routeModule.userland && Array.isArray(ComponentMod.routeModule.userland.loaderTree)) {
+                resolveParallelRouteParams(ComponentMod.routeModule.userland.loaderTree, params, pathname, fallbackRouteParams);
+            }
             const fallbackRootParams = [];
             for (const { paramName, isParallelRouteParam } of fallbackRouteParams){
                 // Only add the param to the fallback root params if it's not a