failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/build/static-paths/app.js

@@ -50,6 +50,8 @@ const _interceptionprefixfromparamtype = require("../../shared/lib/router/utils/
 const _isplainobject = require("../../shared/lib/is-plain-object");
 const _workunitasyncstorageexternal = require("../../server/app-render/work-unit-async-storage.external");
 const _implicittags = require("../../server/lib/implicit-tags");
+const _ensurestaticgsperrors = require("../../shared/lib/errors/ensure-static-gsp-errors");
+const _parammatching = require("./param-matching");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -231,17 +233,9 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
     if (isRoutePPREnabled && rootParamKeys.length > 0) {
         if (routeParams.length === 0 || rootParamKeys.some((key)=>routeParams.some((params)=>!(key in params)))) {
             if (rootParamKeys.length === 1) {
-                throw Object.defineProperty(new Error(`A required root parameter (${rootParamKeys[0]}) was not provided in generateStaticParams for ${page}, please provide at least one value.`), "__NEXT_ERROR_CODE", {
-                    value: "E622",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`A required root parameter (${rootParamKeys[0]}) was not provided in generateStaticParams for ${page}, please provide at least one value.`);
             }
-            throw Object.defineProperty(new Error(`Required root params (${rootParamKeys.join(', ')}) were not provided in generateStaticParams for ${page}, please provide at least one value for each.`), "__NEXT_ERROR_CODE", {
-                value: "E621",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Required root params (${rootParamKeys.join(', ')}) were not provided in generateStaticParams for ${page}, please provide at least one value for each.`);
         }
     }
     for (const params of routeParams){
@@ -263,19 +257,11 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
             // parameter or not.
             if (repeat) {
                 if (!Array.isArray(paramValue)) {
-                    throw Object.defineProperty(new Error(`A required parameter (${key}) was not provided as an array received ${typeof paramValue} in generateStaticParams for ${page}`), "__NEXT_ERROR_CODE", {
-                        value: "E618",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`A required parameter (${key}) was not provided as an array received ${typeof paramValue} in generateStaticParams for ${page}`);
                 }
             } else {
                 if (typeof paramValue !== 'string') {
-                    throw Object.defineProperty(new Error(`A required parameter (${key}) was not provided as a string received ${typeof paramValue} in generateStaticParams for ${page}`), "__NEXT_ERROR_CODE", {
-                        value: "E617",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`A required parameter (${key}) was not provided as a string received ${typeof paramValue} in generateStaticParams for ${page}`);
                 }
             }
             item[key] = paramValue;
@@ -284,7 +270,25 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
     }
     return valid;
 }
-function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments) {
+function getRemainingPrerenderableParams(params, fallbackRouteParams, pathnameSegments) {
+    const fallbackRouteParamsByName = new Map(fallbackRouteParams.map((param)=>[
+            param.paramName,
+            param
+        ]));
+    const remainingPrerenderableParams = [];
+    // Only unresolved pathname params that can still be prerendered belong
+    // here. Once we hit a purely dynamic param, the rest of the shell also
+    // stays dynamic and cannot be completed into a more specific prerender.
+    for (const segment of pathnameSegments){
+        if (params.hasOwnProperty(segment.paramName)) continue;
+        if (!segment.isPrerenderable) break;
+        const fallbackRouteParam = fallbackRouteParamsByName.get(segment.paramName);
+        if (!fallbackRouteParam) break;
+        remainingPrerenderableParams.push(fallbackRouteParam);
+    }
+    return remainingPrerenderableParams.length > 0 ? remainingPrerenderableParams : undefined;
+}
+function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments, explicitFallbackParamName) {
     // If there are no routes to process, exit early.
     if (prerenderedRoutes.length === 0) {
         return;
@@ -293,7 +297,8 @@ function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments) {
     // before any parameters have been considered.
     const root = {
         children: new Map(),
-        routes: []
+        routes: [],
+        hasValidatedPolicyAncestor: false
     };
     // Phase 1: Build the Trie.
     // Iterate over each prerendered route and insert it into the Trie.
@@ -333,7 +338,8 @@ function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments) {
                     // the current node's children.
                     childNode = {
                         children: new Map(),
-                        routes: []
+                        routes: [],
+                        hasValidatedPolicyAncestor: false
                     };
                     currentNode.children.set(valueKey, childNode);
                 }
@@ -352,18 +358,28 @@ function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments) {
     // for very deep routing structures.
     const stack = [
         root
-    ] // Initialize the stack with the root node.
-    ;
+    ];
     while(stack.length > 0){
-        const node = stack.pop()// Pop the next node to process from the stack.
-        ;
+        const node = stack.pop();
+        const { hasValidatedPolicyAncestor } = node;
         // `hasChildren` indicates if this node has any more specific concrete
         // parameter combinations branching off from it. If true, it means this
         // node represents a prefix for other, more specific routes.
         const hasChildren = node.children.size > 0;
+        let policyValidationRoute;
         // If the current node has routes associated with it (meaning, routes whose
         // concrete parameters lead to this node's path in the Trie).
         if (node.routes.length > 0) {
+            if (!hasValidatedPolicyAncestor && explicitFallbackParamName) {
+                for (const route of node.routes){
+                    var _fallbackRouteParams_, _policyValidationRoute_fallbackRouteParams;
+                    const fallbackRouteParams = route.fallbackRouteParams ?? [];
+                    const isExplicitFallback = route.fallbackMode === _fallback.FallbackMode.PRERENDER && ((_fallbackRouteParams_ = fallbackRouteParams[0]) == null ? void 0 : _fallbackRouteParams_.paramName) === explicitFallbackParamName;
+                    if (isExplicitFallback && (!policyValidationRoute || fallbackRouteParams.length > (((_policyValidationRoute_fallbackRouteParams = policyValidationRoute.fallbackRouteParams) == null ? void 0 : _policyValidationRoute_fallbackRouteParams.length) ?? 0))) {
+                        policyValidationRoute = route;
+                    }
+                }
+            }
             // Determine the minimum number of fallback parameters among all routes
             // that are associated with this current Trie node. This is used to
             // identify if a route should not throw on empty static shell relative to another route *at the same level*
@@ -376,9 +392,12 @@ function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments) {
             }
             // Now, for each `PrerenderedRoute` associated with this node:
             for (const route of node.routes){
-                // A route is ok not to throw on an empty static shell (and thus
-                // `throwOnEmptyStaticShell` should be `false`) if either of the
-                // following conditions is met:
+                // An explicit fallback or blocking boundary must validate exactly one
+                // shell for this branch. Once that succeeds, more specific shells do
+                // not need to repeat the same validation.
+                //
+                // Without an explicit policy validation, a route is ok not to throw
+                // on an empty static shell if either of the following conditions is met:
                 // 1. `hasChildren` is true: This node has further concrete parameter children.
                 //    This means the current route is a parent to more specific routes (e.g.,
                 //    `/blog/[slug]` should not throw when concrete routes like `/blog/first-post` exist).
@@ -388,43 +407,21 @@ function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments) {
                 //    This implies the current route is a more general version that should not throw
                 //    compared to a more specific route that has fewer fallback parameters
                 //    (e.g., `/1234/[...slug]` should not throw relative to `/[id]/[...slug]`).
-                if (hasChildren || route.fallbackRouteParams && route.fallbackRouteParams.length > minFallbacks) {
+                if (policyValidationRoute) {
+                    route.throwOnEmptyStaticShell = route === policyValidationRoute;
+                } else if (hasValidatedPolicyAncestor || hasChildren || route.fallbackRouteParams && route.fallbackRouteParams.length > minFallbacks) {
                     route.throwOnEmptyStaticShell = false // Should not throw on empty static shell.
                     ;
                 } else {
                     route.throwOnEmptyStaticShell = true // Should throw on empty static shell.
                     ;
                 }
-                if (route.fallbackRouteParams && route.fallbackRouteParams.length > 0) {
-                    const fallbackRouteParamsByName = new Map(route.fallbackRouteParams.map((param)=>[
-                            param.paramName,
-                            param
-                        ]));
-                    const remainingPrerenderableParams = [];
-                    // Only unresolved pathname params that can still be filled by
-                    // generateStaticParams belong here. Once we hit an unresolved param
-                    // that is purely dynamic, the rest of the shell also stays dynamic
-                    // and cannot be completed into a more specific prerendered shell.
-                    for (const segment of pathnameSegments){
-                        if (route.params.hasOwnProperty(segment.paramName)) {
-                            continue;
-                        }
-                        if (!segment.hasGenerateStaticParams) {
-                            break;
-                        }
-                        const fallbackRouteParam = fallbackRouteParamsByName.get(segment.paramName);
-                        if (!fallbackRouteParam) {
-                            break;
-                        }
-                        remainingPrerenderableParams.push(fallbackRouteParam);
-                    }
-                    route.remainingPrerenderableParams = remainingPrerenderableParams.length > 0 ? remainingPrerenderableParams : undefined;
-                }
             }
         }
         // Add all children of the current node to the stack. This ensures that
         // the traversal continues to explore deeper paths in the Trie.
         for (const child of node.children.values()){
+            child.hasValidatedPolicyAncestor = hasValidatedPolicyAncestor || policyValidationRoute !== undefined;
             stack.push(child);
         }
     }
@@ -445,7 +442,8 @@ function getValueType(value) {
         }
     }
     const workUnitStore = {
-        type: 'generate-static-params',
+        type: 'build-time-generator',
+        functionName: 'generateStaticParams',
         phase: 'render',
         implicitTags,
         rootParams
@@ -454,26 +452,14 @@ function getValueType(value) {
         params: parentParams
     });
     if (!Array.isArray(generatedParams)) {
-        throw Object.defineProperty(new Error(`Invalid value returned from generateStaticParams for "${page}". Expected an array, but received type ${getValueType(generatedParams)}. See more info here: https://nextjs.org/docs/messages/generate-static-params`), "__NEXT_ERROR_CODE", {
-            value: "E1450",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invalid value returned from generateStaticParams for "${page}". Expected an array, but received type ${getValueType(generatedParams)}. See more info here: https://nextjs.org/docs/messages/generate-static-params`);
     }
     if (isStaticExport && generatedParams.length === 0) {
-        throw Object.defineProperty(new Error(`Page "${page}" returned an empty array from "generateStaticParams()". With "output: export", at least one route must be generated. See more info here: https://nextjs.org/docs/messages/generate-static-params`), "__NEXT_ERROR_CODE", {
-            value: "E1454",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Page "${page}" returned an empty array from "generateStaticParams()". With "output: export", at least one route must be generated. See more info here: https://nextjs.org/docs/messages/generate-static-params`);
     }
     for (const [index, params] of generatedParams.entries()){
         if (!(0, _isplainobject.isPlainObject)(params)) {
-            throw Object.defineProperty(new Error(`Invalid value at index ${index} returned from generateStaticParams for "${page}". Expected an object, but received type ${getValueType(params)}. See more info here: https://nextjs.org/docs/messages/generate-static-params`), "__NEXT_ERROR_CODE", {
-                value: "E1451",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Invalid value at index ${index} returned from generateStaticParams for "${page}". Expected an object, but received type ${getValueType(params)}. See more info here: https://nextjs.org/docs/messages/generate-static-params`);
         }
     }
     return generatedParams;
@@ -563,16 +549,12 @@ function createReplacements(segment, paramValue) {
         encodeURIComponent)
     };
 }
-async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, useCacheTimeout, staticPageGenerationTimeout, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, buildId, deploymentId, rootParamKeys }) {
+async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, useCacheTimeout, durableUseCacheEntries, staticPageGenerationTimeout, segments, segmentTree, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, isEnsureStaticPage, buildId, deploymentId, rootParamKeys }) {
     if (segments.some((generate)=>{
         var _generate_config;
         return ((_generate_config = generate.config) == null ? void 0 : _generate_config.dynamicParams) === true;
     }) && nextConfigOutput === 'export') {
-        throw Object.defineProperty(new Error('"dynamicParams: true" cannot be used with "output: export". See more info here: https://nextjs.org/docs/app/building-your-application/deploying/static-exports'), "__NEXT_ERROR_CODE", {
-            value: "E393",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('"dynamicParams: true" cannot be used with "output: export". See more info here: https://nextjs.org/docs/app/building-your-application/deploying/static-exports');
     }
     ComponentMod.patchFetch();
     const incrementalCache = await (0, _createincrementalcache.createIncrementalCache)({
@@ -590,6 +572,10 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
     //   interception routes in parallel slots) that match the pathname
     // For AppRouteRouteModule: Filters the segments array to get non-parallel route params
     const pathnameRouteParamSegments = (0, _utils.extractPathnameRouteParamSegments)(ComponentMod.routeModule, segments, route);
+    const hasParamMatchingExport = segments.some((segment)=>segment.paramMatching !== undefined);
+    if (hasParamMatchingExport && !cacheComponents) {
+        throw new Error(`Route "${page}" cannot use parameter matching without enabling \`cacheComponents\`.`);
+    }
     const afterRunner = new _runwithafter.AfterRunner();
     const store = (0, _workstore.createWorkStore)({
         page,
@@ -597,7 +583,6 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
             incrementalCache,
             cacheLifeProfiles,
             staticPageGenerationTimeout,
-            supportsDynamicResponse: true,
             cacheComponents,
             // generateStaticParams evaluation doesn't render pages, so instant
             // validation never runs here. The level value is irrelevant.
@@ -605,7 +590,8 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
             validationLevel: 'warning',
             experimental: {
                 authInterrupts,
-                useCacheTimeout
+                useCacheTimeout,
+                durableUseCacheEntries
             },
             waitUntil: afterRunner.context.waitUntil,
             onClose: afterRunner.context.onClose,
@@ -615,17 +601,68 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         deploymentId,
         previouslyRevalidatedTags: []
     });
+    const paramMatching = hasParamMatchingExport ? await _workasyncstorageexternal.workAsyncStorage.run(store, async ()=>{
+        const generatorStore = {
+            type: 'build-time-generator',
+            functionName: 'unstable_generateParamMatching',
+            phase: 'render',
+            implicitTags: await (0, _implicittags.getImplicitTags)(page, page, null),
+            // Matching configuration does not receive concrete parameter values.
+            rootParams: {}
+        };
+        return _workunitasyncstorageexternal.workUnitAsyncStorage.run(generatorStore, _parammatching.resolveParamMatching, page, segmentTree, pathnameRouteParamSegments);
+    }) : undefined;
+    // Validate the effective route policy, after layout overrides and parallel
+    // branches have been merged. Navigation mode cannot serve a fallback and
+    // resume it, or leave any parameter permanently dynamic.
+    if (isEnsureStaticPage && paramMatching) {
+        for (const [paramName, mode] of Object.entries(paramMatching)){
+            if (mode === 'fallback' || mode === 'dynamic') {
+                throw new Error(`Route "${page}" cannot configure parameter "${paramName}" as "${mode}" with \`ensureStatic = "navigation"\`. Use "blocking" or "not-found" parameter matching, or remove the navigation constraint.`);
+            }
+        }
+    }
     const routeParams = await _workasyncstorageexternal.workAsyncStorage.run(store, generateRouteStaticParams, segments, store, isRoutePPREnabled, rootParamKeys, nextConfigOutput === 'export');
     const generatedParamNames = new Set();
-    for (const params of routeParams){
-        for (const paramName of Object.keys(params)){
-            generatedParamNames.add(paramName);
+    const missingParamNames = new Set();
+    if (routeParams.length > 0) {
+        for (const { paramName } of pathnameRouteParamSegments){
+            for (const params of routeParams){
+                if (paramName in params) {
+                    generatedParamNames.add(paramName);
+                } else {
+                    missingParamNames.add(paramName);
+                }
+            }
         }
     }
-    const prerenderablePathSegments = pathnameRouteParamSegments.map((segment)=>({
+    // An explicitly prerenderable parameter also makes its unconfigured prefix
+    // prerenderable, even without build-time examples. Only the unconfigured
+    // suffix after this boundary can remain permanently dynamic.
+    const lastConfiguredPrerenderableParamIndex = pathnameRouteParamSegments.findLastIndex(({ paramName })=>{
+        const mode = paramMatching == null ? void 0 : paramMatching[paramName];
+        return mode === 'blocking' || mode === 'fallback';
+    });
+    const prerenderablePathSegments = pathnameRouteParamSegments.map((segment, index)=>{
+        const mode = paramMatching == null ? void 0 : paramMatching[segment.paramName];
+        return {
             paramName: segment.paramName,
-            hasGenerateStaticParams: generatedParamNames.has(segment.paramName)
-        }));
+            isPrerenderable: mode === 'blocking' || mode === 'fallback' || mode === undefined && (index < lastConfiguredPrerenderableParamIndex || generatedParamNames.has(segment.paramName))
+        };
+    });
+    let explicitFallbackRouteParams;
+    if (paramMatching) {
+        const firstFallbackParamIndex = pathnameRouteParamSegments.findIndex(({ paramName })=>paramMatching[paramName] === 'fallback');
+        if (firstFallbackParamIndex !== -1) {
+            explicitFallbackRouteParams = pathnameRouteParamSegments.slice(firstFallbackParamIndex).map(({ paramName, paramType })=>({
+                    paramName,
+                    paramType
+                }));
+        }
+    }
+    if (paramMatching) {
+        (0, _parammatching.validateParamMatchingParams)(page, paramMatching, generatedParamNames, missingParamNames, pathnameRouteParamSegments, nextConfigOutput);
+    }
     await afterRunner.executeAfter();
     let lastDynamicSegmentHadGenerateStaticParams = false;
     for (const segment of segments){
@@ -636,11 +673,7 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
             for (const params of routeParams){
                 if (segment.paramName in params) continue;
                 const relative = segment.filePath ? _nodepath.default.relative(dir, segment.filePath) : undefined;
-                throw Object.defineProperty(new Error(`Segment "${relative}" exports "dynamicParams: false" but the param "${segment.paramName}" is missing from the generated route params.`), "__NEXT_ERROR_CODE", {
-                    value: "E280",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Segment "${relative}" exports "dynamicParams: false" but the param "${segment.paramName}" is missing from the generated route params.`);
             }
         }
         if (segment.paramName && segment.paramType && typeof segment.generateStaticParams !== 'function') {
@@ -649,22 +682,25 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
             lastDynamicSegmentHadGenerateStaticParams = true;
         }
     }
-    const missingParamNames = [];
-    if (routeParams.length > 0) {
-        for (const { paramName } of pathnameRouteParamSegments){
-            if (routeParams.some((params)=>!(paramName in params))) {
-                missingParamNames.push(paramName);
-            }
-        }
-    }
     // Determine if all the segments have had their parameters provided.
-    const hadAllParamsGenerated = pathnameRouteParamSegments.length === 0 || routeParams.length > 0 && missingParamNames.length === 0;
+    const hadAllParamsGenerated = pathnameRouteParamSegments.length === 0 || routeParams.length > 0 && missingParamNames.size === 0;
     if (nextConfigOutput === 'export' && routeParams.length > 0 && !hadAllParamsGenerated) {
-        throw Object.defineProperty(new Error(`Page "${page}" returned incomplete params from "generateStaticParams()". With "output: export", every params object must include all dynamic route parameters. Missing: ${missingParamNames.map((name)=>`"${name}"`).join(', ')}. See more info here: https://nextjs.org/docs/messages/generate-static-params`), "__NEXT_ERROR_CODE", {
-            value: "E1455",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Page "${page}" returned incomplete params from "generateStaticParams()". With "output: export", every params object must include all dynamic route parameters. Missing: ${[
+            ...missingParamNames
+        ].map((name)=>`"${name}"`).join(', ')}. See more info here: https://nextjs.org/docs/messages/generate-static-params`);
+    }
+    // `ensureStatic = "navigation"` currently requires all params to
+    // be prerendered via gSP.
+    if (isEnsureStaticPage && pathnameRouteParamSegments.length > 0) {
+        if (routeParams.length === 0) {
+            // In Cache Components we throw in `generateRouteStaticParams` for empty arrays,
+            // so empty `routeParams` implies that no `generateStaticParams` is present at all
+            (0, _ensurestaticgsperrors.throwMissingGspErrorInStaticRoute)(page);
+        } else if (!hadAllParamsGenerated) {
+            (0, _ensurestaticgsperrors.throwIncompleteStaticParamsErrorInStaticRoute)(page, [
+                ...missingParamNames
+            ]);
+        }
     }
     // TODO: dynamic params should be allowed to be granular per segment but
     // we need additional information stored/leveraged in the prerender
@@ -674,13 +710,69 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         return ((_segment_config = segment.config) == null ? void 0 : _segment_config.dynamicParams) !== false;
     });
     const supportsRoutePreGeneration = hadAllParamsGenerated || !process.env.__NEXT_DEV_SERVER;
-    const fallbackMode = dynamicParams ? supportsRoutePreGeneration ? isRoutePPREnabled ? _fallback.FallbackMode.PRERENDER : _fallback.FallbackMode.BLOCKING_STATIC_RENDER : undefined : _fallback.FallbackMode.NOT_FOUND;
-    const prerenderedRoutesByPathname = new Map();
-    // Convert rootParamKeys to Set for O(1) lookup.
+    const inferredFallbackMode = dynamicParams ? supportsRoutePreGeneration ? isRoutePPREnabled ? isEnsureStaticPage ? _fallback.FallbackMode.BLOCKING_STATIC_RENDER : _fallback.FallbackMode.PRERENDER : _fallback.FallbackMode.BLOCKING_STATIC_RENDER : undefined : _fallback.FallbackMode.NOT_FOUND;
     const rootParamSet = new Set(rootParamKeys);
+    const fallbackMode = paramMatching ? (0, _parammatching.getParamMatchingFallbackMode)(paramMatching, pathnameRouteParamSegments, inferredFallbackMode, rootParamSet) : inferredFallbackMode;
+    const getRouteFallbackMode = (fallbackRouteParams, fallbackRootParams)=>{
+        if (paramMatching) {
+            return (0, _parammatching.getParamMatchingFallbackMode)(paramMatching, fallbackRouteParams, inferredFallbackMode, rootParamSet);
+        }
+        return calculateFallbackMode(dynamicParams, fallbackRootParams, fallbackMode);
+    };
+    const prerenderedRoutesByPathname = new Map();
+    const blockingCandidatesByPathname = new Map();
+    const prerenderRouteMatchersByPathname = new Map();
+    const addPrerenderCandidate = (params, pathname, encodedPathname, fallbackRouteParams, fallbackRootParams)=>{
+        const routeFallbackMode = getRouteFallbackMode(fallbackRouteParams, fallbackRootParams);
+        const remainingPrerenderableParams = cacheComponents && fallbackRouteParams.length > 0 ? getRemainingPrerenderableParams(params, fallbackRouteParams, prerenderablePathSegments) : undefined;
+        if (fallbackRouteParams.length > 0 && (isRoutePPREnabled || paramMatching)) {
+            var _remainingPrerenderableParams_;
+            prerenderRouteMatchersByPathname.set(pathname, {
+                pathname,
+                fallbackRouteParams,
+                fallbackMode: routeFallbackMode,
+                isFallbackModeInferred: paramMatching && routeFallbackMode === _fallback.FallbackMode.PRERENDER && paramMatching[fallbackRouteParams[0].paramName] === undefined && (remainingPrerenderableParams == null ? void 0 : (_remainingPrerenderableParams_ = remainingPrerenderableParams[0]) == null ? void 0 : _remainingPrerenderableParams_.paramName) === fallbackRouteParams[0].paramName ? true : undefined,
+                fallbackRootParams,
+                remainingPrerenderableParams
+            });
+        }
+        const prerenderCandidate = {
+            params,
+            pathname,
+            encodedPathname,
+            fallbackRouteParams,
+            fallbackMode: routeFallbackMode,
+            fallbackRootParams,
+            remainingPrerenderableParams,
+            isPrerenderOutput: paramMatching && fallbackRouteParams.length > 0 && routeFallbackMode === _fallback.FallbackMode.BLOCKING_STATIC_RENDER ? false : undefined,
+            throwOnEmptyStaticShell: true
+        };
+        if (isEnsureStaticPage && fallbackRouteParams.length > 0) {
+            // Navigation mode still needs the generic render's prefetch data. Other
+            // prefixes only need matchers: /en/[slug] can admit a novel slug beneath
+            // a closed language without rendering or serving a partial fallback.
+            if (pathname === page) {
+                prerenderedRoutesByPathname.set(pathname, prerenderCandidate);
+            }
+            return;
+        }
+        // Explicit blocking policies do not produce fallback outputs, but may
+        // still need a render for prefetch hints and shell validation. Keep their
+        // candidates until we know whether a more specific render covers them.
+        // Not-found candidates do not need to render at all.
+        if (paramMatching && fallbackRouteParams.length > 0 && routeFallbackMode !== _fallback.FallbackMode.PRERENDER) {
+            if (routeFallbackMode === _fallback.FallbackMode.BLOCKING_STATIC_RENDER) {
+                blockingCandidatesByPathname.set(pathname, prerenderCandidate);
+            }
+            return;
+        }
+        prerenderedRoutesByPathname.set(pathname, prerenderCandidate);
+    };
     if (hadAllParamsGenerated || isRoutePPREnabled) {
         let paramsToProcess = routeParams;
         if (isRoutePPREnabled) {
+            // NOTE: we do this even if `ensureStatic = "navigation"` is set because
+            // most of the build plumbing assumes that we'll have done fallback prerenders.
             // Discover all unique combinations of the routeParams so we can generate
             // routes that won't throw on empty static shell for each of them if
             // they're available.
@@ -696,15 +788,7 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
             }
             // Add the base route, this is the route with all the placeholders as it's
             // derived from the `page` string.
-            prerenderedRoutesByPathname.set(page, {
-                params: {},
-                pathname: page,
-                encodedPathname: page,
-                fallbackRouteParams,
-                fallbackMode: calculateFallbackMode(dynamicParams, rootParamKeys, fallbackMode),
-                fallbackRootParams: rootParamKeys,
-                throwOnEmptyStaticShell: true
-            });
+            addPrerenderCandidate({}, page, page, fallbackRouteParams, rootParamKeys);
         }
         filterUniqueParams(pathnameRouteParamSegments, validateParams(page, isRoutePPREnabled, pathnameRouteParamSegments, rootParamKeys, paramsToProcess)).forEach((params)=>{
             let pathname = page;
@@ -713,7 +797,9 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
             for (const { name, paramName, paramType } of pathnameRouteParamSegments){
                 const paramValue = params[paramName];
                 if (!paramValue) {
-                    if (isRoutePPREnabled) {
+                    if (isRoutePPREnabled && // Navigation mode does not render intermediate fallbacks, but
+                    // parameter matching may still need their specialized matchers.
+                    (!isEnsureStaticPage || paramMatching !== undefined)) {
                         // Mark remaining params as fallback params.
                         fallbackRouteParams.push({
                             paramName,
@@ -756,27 +842,38 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
                 }
             }
             pathname = (0, _utils.normalizePathname)(pathname);
-            prerenderedRoutesByPathname.set(pathname, {
-                params,
-                pathname,
-                encodedPathname: (0, _utils.normalizePathname)(encodedPathname),
-                fallbackRouteParams,
-                fallbackMode: calculateFallbackMode(dynamicParams, fallbackRootParams, fallbackMode),
-                fallbackRootParams,
-                throwOnEmptyStaticShell: true
-            });
+            addPrerenderCandidate(params, pathname, (0, _utils.normalizePathname)(encodedPathname), fallbackRouteParams, fallbackRootParams);
         });
     }
-    const prerenderedRoutes = prerenderedRoutesByPathname.size > 0 || lastDynamicSegmentHadGenerateStaticParams ? [
-        ...prerenderedRoutesByPathname.values()
+    let prerenderedRoutes = prerenderedRoutesByPathname.size > 0 || blockingCandidatesByPathname.size > 0 || lastDynamicSegmentHadGenerateStaticParams ? [
+        ...prerenderedRoutesByPathname.values(),
+        ...blockingCandidatesByPathname.values()
     ] : undefined;
-    // Now we have to set the throwOnEmptyStaticShell for each of the routes.
-    if (prerenderedRoutes && cacheComponents) {
-        assignStaticShellMetadata(prerenderedRoutes, prerenderablePathSegments);
+    if (cacheComponents) {
+        var _explicitFallbackRouteParams_;
+        const explicitFallbackParamName = explicitFallbackRouteParams == null ? void 0 : (_explicitFallbackRouteParams_ = explicitFallbackRouteParams[0]) == null ? void 0 : _explicitFallbackRouteParams_.paramName;
+        if (prerenderedRoutes) {
+            assignStaticShellMetadata(prerenderedRoutes, prerenderablePathSegments, explicitFallbackParamName);
+            // Keep blocking candidates without a more specific render so the build
+            // can collect best-effort prefetch hints, even with instant=false. The
+            // renderer handles that validation opt-out; it must not skip this render.
+            // Explicit matching can skip candidates covered by a descendant.
+            // Without matching configuration, preserve every historical render:
+            // its output may still contribute the route's prefetch hints.
+            if (paramMatching !== undefined && !isEnsureStaticPage) {
+                prerenderedRoutes = prerenderedRoutes.filter((candidate)=>candidate.fallbackMode !== _fallback.FallbackMode.BLOCKING_STATIC_RENDER || candidate.throwOnEmptyStaticShell);
+            }
+        }
     }
+    const prerenderRouteMatchers = prerenderRouteMatchersByPathname.size > 0 ? [
+        ...prerenderRouteMatchersByPathname.values()
+    ] : undefined;
     return {
         fallbackMode,
-        prerenderedRoutes
+        prerenderedRoutes,
+        prerenderRouteMatchers,
+        paramMatching,
+        explicitFallbackRouteParams
     };
 }