vinext 1.0.0-beta.9 → 1.0.0

package/dist/build/prerender-paths.js

@@ -1,24 +1,27 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { findDir } from "../utils/project.js";
-import { apiRouter, matchRoute, pagesRouter } from "../routing/pages-router.js";
+import { BLOCKED_PAGES, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
-import "../server/headers.js";
+import { isExternalUrl } from "../utils/external-url.js";
 import { matchHeaders, matchesRewriteSource } from "../config/config-matchers.js";
-import { extractLocaleFromUrl, normalizeDefaultLocalePathname } from "../server/pages-i18n.js";
-import { classifyAppRoute, classifyAppRouteHandler, classifyPagesRoute, extractExportConstString, getAppRouteRenderEntryPath } from "./report.js";
+import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
 import { appRouteHasMainTreeLoadingBoundary, appRouter, matchAppRoute } from "../routing/app-router.js";
+import { apiRouter, matchRoute, pagesRouter } from "../routing/pages-router.js";
+import "../server/headers.js";
+import { matchesMiddlewarePathname } from "../server/middleware-matcher.js";
+import { extractLocaleFromUrl, normalizeDefaultLocalePathname } from "../server/pages-i18n.js";
+import { classifyAppRoute, classifyAppRouteHandler, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractMiddlewareMatcherConfig, getAppRouteRenderEntryPath, hasRuntimeExportedName } from "./report.js";
 import { normalizeStaticPathname, normalizeStaticPathsEntry } from "../routing/route-pattern.js";
 import { buildPagesDataHref } from "../shims/internal/pages-data-url.js";
 import { normalizePathTrailingSlash } from "../shims/url-utils.js";
-import { BLOCKED_PAGES, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
-import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
-import { CACHEABILITY_POLICY_HEADERS } from "../shims/cacheability-classification.js";
 import { pagesRouteHasPriorityOverAppRoute } from "../server/hybrid-route-priority.js";
 import { readPrerenderSecret } from "./server-manifest.js";
+import { loadMdxEsmReader } from "../utils/mdx-scan.js";
 import { startProdServer } from "../server/prod-server.js";
 import { enterPrerenderPhase } from "./prerender-phase.js";
-import { buildUrlFromParams, resolveParentParams } from "./prerender.js";
-import { resolveAppPageDynamicConfig } from "../server/app-segment-config.js";
+import { buildUrlFromParams, layoutOnlyParamSets, resolveParentParams, routeStaticParamSets, validateDiscoveredParams } from "./prerender.js";
+import { collectAppPageStaticGenerationRuntimes, hasAppPageGenerateStaticParamsAtLastDynamicSegment, isAppPageStaticEligible, isEdgeRuntime, resolveAppPageDynamicConfig, resolveAppPageSegmentConfig, resolveAppPageStaticGenerationRuntime } from "../server/app-segment-config.js";
+import { resolveBuiltRscEntryPath } from "./server-entry.js";
 import fs from "node:fs";
 //#region src/build/prerender-paths.ts
 const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
@@ -62,7 +65,7 @@ function addPath(paths, seen, pathname) {
 }
 function throwDiscoveryFailure(route, error) {
 	const message = error instanceof Error ? error.message : String(error);
-	if (/cloudflare:|ERR_UNSUPPORTED_ESM_URL_SCHEME/i.test(message)) throw new Error(`Failed to discover warmup path(s) for ${route}: Cloudflare runtime bindings cannot execute in the local Node prerender server. Use \`vinext-cloudflare deploy --experimental-warm-cdn-cache\` so path discovery runs against the staged Worker version.`, { cause: error });
+	if (/cloudflare:|ERR_UNSUPPORTED_ESM_URL_SCHEME/i.test(message)) throw new Error(`Failed to discover warmup path(s) for ${route}: Cloudflare runtime bindings cannot execute in the local Node prerender server. Use \`vinext-cloudflare deploy --warm-cache\` so path discovery runs against the staged Worker version.`, { cause: error });
 	throw new Error(`Failed to discover warmup path(s) for ${route}: ${message}`, { cause: error });
 }
 function validatePagesStaticPathsResult(value, route) {
@@ -85,28 +88,6 @@ function hasUnsafeRawUrlPathCharacter(value) {
 	}
 	return false;
 }
-function getDynamicPatternParams(pattern) {
-	return pattern.split("/").filter((segment) => segment.startsWith(":")).map((segment) => ({
-		name: segment.slice(1, segment.endsWith("+") || segment.endsWith("*") ? -1 : void 0),
-		optional: segment.endsWith("*"),
-		repeat: segment.endsWith("+") || segment.endsWith("*")
-	}));
-}
-function validateDiscoveredParams(value, pattern, source) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${source} must return parameter objects for ${pattern}.`);
-	const params = { ...value };
-	for (const { name, optional, repeat } of getDynamicPatternParams(pattern)) {
-		const hasValue = Object.prototype.hasOwnProperty.call(params, name);
-		let paramValue = params[name];
-		if (optional && hasValue && (paramValue === null || paramValue === void 0 || paramValue === false)) {
-			paramValue = [];
-			params[name] = paramValue;
-		}
-		if (!(repeat ? Array.isArray(paramValue) && paramValue.every((entry) => typeof entry === "string") : typeof paramValue === "string")) throw new Error(`Parameter ${name} from ${source} for ${pattern} must be ${repeat ? "an array of strings" : "a string"}.`);
-		if ((Array.isArray(paramValue) ? paramValue : [paramValue]).some((entry) => entry === "." || entry === "..")) throw new Error(`Parameter ${name} from ${source} for ${pattern} must not contain dot path segments.`);
-	}
-	return params;
-}
 function validatePagesStaticPathsEntry(entry, pattern) {
 	if (typeof entry === "string") {
 		if (!entry.startsWith("/") || entry.includes("//") || entry.includes("?") || entry.includes("#") || hasUnsafeRawUrlPathCharacter(entry)) throw new Error(`The provided path \`${entry}\` from getStaticPaths does not match the route pattern \`${pattern}\`.`);
@@ -246,6 +227,8 @@ async function collectPagesPaths(options) {
 	const dataPaths = [];
 	const seenDataPaths = /* @__PURE__ */ new Set();
 	const fallbackRoutePatterns = [];
+	const nonDynamicPaths = [];
+	const seenNonDynamicPaths = /* @__PURE__ */ new Set();
 	for (const route of pageRoutes) {
 		if (apiPatterns.has(route.pattern)) continue;
 		if (BLOCKED_PAGES.includes(route.pattern)) continue;
@@ -256,14 +239,17 @@ async function collectPagesPaths(options) {
 			if (options.i18n) for (const locale of options.i18n.locales) {
 				const pathname = localizePagesPath(route.pattern, locale, options.i18n);
 				addPath(paths, seen, pathname);
+				addPath(nonDynamicPaths, seenNonDynamicPaths, pathname);
 				if (hasStaticProps || hasServerSideProps) addPath(dataPaths, seenDataPaths, pathname);
 			}
 			else {
 				addPath(paths, seen, route.pattern);
+				addPath(nonDynamicPaths, seenNonDynamicPaths, route.pattern);
 				if (hasStaticProps || hasServerSideProps) addPath(dataPaths, seenDataPaths, route.pattern);
 			}
 			continue;
 		}
+		if (!options.enumerateDynamicPaths) continue;
 		if (type === "ssr") continue;
 		if (!options.baseUrl) continue;
 		try {
@@ -301,6 +287,7 @@ async function collectPagesPaths(options) {
 	return {
 		dataPaths,
 		fallbackRoutePatterns,
+		nonDynamicPaths,
 		paths
 	};
 }
@@ -312,15 +299,31 @@ async function excludePagesApiWarmPaths(options) {
 		return matchRoute(pagesPathname, apiRoutes) === null;
 	});
 }
-async function resolvePagesWarmRoutePatterns(options) {
+async function resolvePagesWarmRouteMetadata(options) {
 	const pageRoutes = await pagesRouter(options.pagesDir, options.pageExtensions);
-	return Object.fromEntries(options.paths.flatMap((pathname) => {
-		const match = matchRoute(options.i18n ? extractLocaleFromUrl(pathname, options.i18n).url : pathname, pageRoutes);
-		return match ? [[pathname, {
+	const classifications = /* @__PURE__ */ new Map();
+	const dataPaths = [];
+	const routePatterns = {};
+	for (const pathname of options.paths) {
+		const pagesPathname = options.i18n ? extractLocaleFromUrl(pathname, options.i18n).url : pathname;
+		const match = matchRoute(pagesPathname, pageRoutes);
+		if (!match) continue;
+		routePatterns[pathname] = {
 			kind: "pages-page",
 			pattern: match.route.pattern
-		}]] : [];
-	}));
+		};
+		let classification = classifications.get(match.route.filePath);
+		if (!classification) {
+			classification = classifyPagesRoute(match.route.filePath);
+			classifications.set(match.route.filePath, classification);
+		}
+		const { hasServerSideProps, hasStaticProps } = classification;
+		if (hasServerSideProps || hasStaticProps) dataPaths.push(pathname);
+	}
+	return {
+		dataPaths,
+		routePatterns
+	};
 }
 function localizePagesPath(pathname, locale, i18n) {
 	if (!i18n || !locale || locale === i18n.defaultLocale) return pathname;
@@ -352,27 +355,110 @@ function extractPagesStaticPathLocale(url, i18n) {
 		url: `${rest || "/"}${query}`
 	};
 }
+/**
+* Whether Next.js classifies an App page route as static or SSG, read from its
+* layout, page and parallel-slot sources with the helpers dispatch applies to
+* the loaded modules. Only such a route has listed paths.
+*
+* An MDX source read without the MDX parser has unknown exports, so its route
+* is "unreadable". Its paths are still listed: the built runtime reads the real
+* exports and never stores a route that isn't static, while an unlisted path's
+* render failure would be dropped instead of failing. But no probe renders an
+* unreadable route's fallback, so it never certifies one.
+*/
+function classifyAppPageRouteStaticEligibility(route, readMdxEsm) {
+	let unreadable = false;
+	const readSegmentConfig = (filePath) => {
+		if (!filePath) return null;
+		let code = fs.readFileSync(filePath, "utf8");
+		if (filePath.toLowerCase().endsWith(".mdx")) {
+			let esm = null;
+			try {
+				esm = readMdxEsm?.(code) ?? null;
+			} catch {}
+			unreadable ||= esm === null;
+			code = esm ?? "";
+		}
+		const dynamic = extractExportConstString(code, "dynamic");
+		const revalidate = extractExportConstNumber(code, "revalidate");
+		const runtime = extractExportConstString(code, "runtime");
+		return {
+			...dynamic === null ? {} : { dynamic },
+			...hasRuntimeExportedName(code, "generateStaticParams") ? { generateStaticParams() {} } : {},
+			...revalidate === null ? {} : { revalidate },
+			...runtime === null ? {} : { runtime }
+		};
+	};
+	const layouts = route.layouts.map(readSegmentConfig);
+	const page = readSegmentConfig(route.pagePath);
+	const parallelBranches = route.parallelSlots.map((slot) => ({
+		configLayouts: (slot.configLayoutPaths ?? []).map(readSegmentConfig),
+		configLayoutTreePositions: slot.configLayoutTreePositions ?? [],
+		isDefault: !slot.pagePath,
+		layout: readSegmentConfig(slot.layoutPath),
+		name: slot.name,
+		ownerTreePosition: slot.ownerTreePosition ?? null,
+		page: readSegmentConfig(slot.pagePath ?? slot.defaultPath),
+		routeSegments: slot.routeSegments
+	}));
+	if (unreadable) return "unreadable";
+	const segmentConfig = resolveAppPageSegmentConfig({
+		layouts,
+		layoutTreePositions: route.layoutTreePositions,
+		page,
+		parallelBranches,
+		routeSegments: route.routeSegments
+	});
+	return isAppPageStaticEligible({
+		dynamicConfig: segmentConfig.dynamicConfig,
+		hasGenerateStaticParams: hasAppPageGenerateStaticParamsAtLastDynamicSegment({
+			childrenSlot: route.childrenSlot ?? null,
+			layouts,
+			layoutTreePositions: route.layoutTreePositions,
+			page,
+			parallelBranches,
+			routeSegments: route.routeSegments
+		}),
+		isDynamicRoute: route.isDynamic,
+		isStaticGenerationEdgeRuntime: isEdgeRuntime(resolveAppPageStaticGenerationRuntime(collectAppPageStaticGenerationRuntimes({
+			childrenSlot: route.childrenSlot ?? null,
+			layouts,
+			layoutTreePositions: route.layoutTreePositions,
+			page,
+			parallelBranches,
+			routeSegments: route.routeSegments
+		}))),
+		revalidateSeconds: segmentConfig.revalidateSeconds
+	}) ? "eligible" : "ineligible";
+}
+/** Keys a path an App page route lists by the route and the pathname together. */
+function appPageListingKey(routePattern, pathname) {
+	return `${routePattern}\0${pathname}`;
+}
 async function collectAppPaths(options) {
 	const routes = await appRouter(options.appDir, options.pageExtensions);
 	const paths = [];
 	const seen = /* @__PURE__ */ new Set();
-	const loadingShellPaths = [];
-	const seenLoadingShellPaths = /* @__PURE__ */ new Set();
 	const routeHandlerPaths = [];
 	const seenRouteHandlerPaths = /* @__PURE__ */ new Set();
 	const fallbackRoutePatterns = [];
+	const nonDynamicPaths = [];
+	const seenNonDynamicPaths = /* @__PURE__ */ new Set();
+	const listedRoutePaths = /* @__PURE__ */ new Set();
 	const staticParamsCache = /* @__PURE__ */ new Map();
 	let requireNonEmptyStaticParams = false;
 	const staticParamsMap = new Proxy({}, {
 		get(_target, pattern) {
 			return async ({ params }) => {
 				if (!options.baseUrl) return null;
-				const cacheKey = `${pattern}\0${JSON.stringify(params)}`;
+				const rejectEmptyResults = requireNonEmptyStaticParams;
+				const cacheKey = `${pattern}\0${JSON.stringify(params)}\0${rejectEmptyResults}`;
 				let request = staticParamsCache.get(cacheKey);
 				if (request === void 0) {
 					request = (async () => {
 						const search = new URLSearchParams({ pattern });
 						if (Object.keys(params).length > 0) search.set("parentParams", JSON.stringify(params));
+						if (rejectEmptyResults) search.set("rejectEmptyResults", "1");
 						const text = await fetchDiscoveryEndpoint(`${options.baseUrl}/__vinext/prerender/static-params?${search}`, options.secretHeaders, options.retryOptions);
 						if (text === null) return null;
 						const value = JSON.parse(text);
@@ -389,7 +475,7 @@ async function collectAppPaths(options) {
 					staticParamsCache.set(cacheKey, request);
 				}
 				const value = await request;
-				if (requireNonEmptyStaticParams && value?.length === 0) throw new Error("When using Cache Components, all `generateStaticParams` functions must return at least one result. This is to ensure that we can perform build-time validation that there is no other dynamic accesses that would cause a runtime error.\n\nLearn more: https://nextjs.org/docs/messages/empty-generate-static-params");
+				if (rejectEmptyResults && value?.length === 0) throw new Error("When using Cache Components, all `generateStaticParams` functions must return at least one result. This is to ensure that we can perform build-time validation that there is no other dynamic accesses that would cause a runtime error.\n\nLearn more: https://nextjs.org/docs/messages/empty-generate-static-params");
 				return value;
 			};
 		},
@@ -397,6 +483,7 @@ async function collectAppPaths(options) {
 			return false;
 		}
 	});
+	const readMdxEsm = !options.cacheComponents && options.pageExtensions.includes("mdx") ? await loadMdxEsmReader(options.root) : null;
 	for (const route of routes) {
 		const isRouteHandler = route.routePath !== null && route.pagePath === null;
 		const renderEntryPath = isRouteHandler ? route.routePath : getAppRouteRenderEntryPath(route);
@@ -408,19 +495,22 @@ async function collectAppPaths(options) {
 			const { type } = classifyAppRoute(renderEntryPath, route.routePath, route.isDynamic);
 			if (type === "api") continue;
 		}
-		const hasMainTreeLoadingBoundary = appRouteHasMainTreeLoadingBoundary(route);
+		const staticEligibility = isRouteHandler || options.cacheComponents ? "eligible" : classifyAppPageRouteStaticEligibility(route, readMdxEsm);
+		const isStaticEligible = staticEligibility !== "ineligible";
 		const addDiscoveredPath = (pathname) => {
 			if (isRouteHandler) {
 				addPath(routeHandlerPaths, seenRouteHandlerPaths, pathname);
 				return;
 			}
 			addPath(paths, seen, pathname);
-			if (hasMainTreeLoadingBoundary) addPath(loadingShellPaths, seenLoadingShellPaths, pathname);
+			if (isStaticEligible) listedRoutePaths.add(appPageListingKey(route.pattern, pathname));
 		};
 		if (!route.isDynamic) {
 			addDiscoveredPath(route.pattern);
+			addPath(nonDynamicPaths, seenNonDynamicPaths, route.pattern);
 			continue;
 		}
+		if (!options.enumerateDynamicPaths) continue;
 		requireNonEmptyStaticParams = options.cacheComponents && !isRouteHandler;
 		try {
 			const generateStaticParams = staticParamsMap[route.pattern];
@@ -432,20 +522,21 @@ async function collectAppPaths(options) {
 				for (const parentParams of parentParamSets) {
 					const childResults = await generateStaticParams({ params: parentParams });
 					if (childResults === null) {
-						paramSets = null;
+						paramSets = layoutOnlyParamSets(route, parentParamSets);
 						break;
 					}
-					if (Array.isArray(childResults)) for (const childParams of childResults) paramSets.push({
-						...parentParams,
-						...childParams
-					});
+					if (Array.isArray(childResults)) {
+						if (childResults.length === 0) paramSets.push(parentParams);
+						for (const childParams of childResults) paramSets.push({
+							...parentParams,
+							...childParams
+						});
+					}
 				}
+				if (paramSets !== null) paramSets = routeStaticParamSets(route, paramSets);
 			} else {
 				const results = await generateStaticParams({ params: {} });
-				if (results === null) {
-					const layoutParamSets = await resolveParentParams(route, staticParamsMap, { includeLastDynamicSegment: true });
-					paramSets = layoutParamSets.length > 0 ? layoutParamSets : null;
-				} else paramSets = Array.isArray(results) ? results : [];
+				paramSets = results === null ? null : routeStaticParamSets(route, Array.isArray(results) ? results : []);
 			}
 			if (!paramSets?.length) {
 				if (isRouteHandler) {
@@ -475,7 +566,7 @@ async function collectAppPaths(options) {
 					page: readDynamicConfig(renderEntryPath),
 					parallelSegments: parallelSegments.map(readDynamicConfig)
 				});
-				if ((paramSets !== null || dynamicConfig === "force-static" || dynamicConfig === "error") && !hasDynamicSegment) fallbackRoutePatterns.push({
+				if ((paramSets !== null || dynamicConfig === "force-static" || dynamicConfig === "error") && !hasDynamicSegment && staticEligibility === "eligible") fallbackRoutePatterns.push({
 					kind: "app-page",
 					pattern: route.pattern
 				});
@@ -491,13 +582,15 @@ async function collectAppPaths(options) {
 	}
 	return {
 		fallbackRoutePatterns,
-		loadingShellPaths,
+		nonDynamicPaths,
 		paths,
-		routeHandlerPaths
+		routeHandlerPaths,
+		listedRoutePaths
 	};
 }
 async function resolveAppWarmPaths(options) {
 	const appRoutes = await appRouter(options.appDir, options.pageExtensions);
+	const loadingBoundaryRoutePatterns = appRoutes.filter((route) => !(route.routePath && !route.pagePath) && appRouteHasMainTreeLoadingBoundary(route)).map((route) => route.pattern).sort();
 	const routeHandlerClassifications = new Map(appRoutes.flatMap((route) => route.routePath && !route.pagePath ? [[route.routePath, classifyAppRouteHandler(route.routePath)]] : []));
 	const [pageRoutes, apiRoutes] = options.pagesDir ? await Promise.all([pagesRouter(options.pagesDir, options.pageExtensions), apiRouter(options.pagesDir, options.pageExtensions)]) : [[], []];
 	const rscPaths = [];
@@ -552,13 +645,13 @@ async function resolveAppWarmPaths(options) {
 		appPaths,
 		appRoutePaths,
 		htmlPaths,
+		loadingBoundaryRoutePatterns,
 		loadingShellPaths,
 		pagesPaths,
 		routePatterns,
 		rscPaths
 	};
 }
-const CACHEABILITY_POLICY_HEADER_NAMES = new Set(CACHEABILITY_POLICY_HEADERS);
 function cachePolicyRuleMatchesWarmPath(pathname, rule, config) {
 	const canonicalPathname = normalizePathTrailingSlash(pathname, config.trailingSlash);
 	return [void 0, ...config.i18n?.domains?.map((domain) => domain.domain) ?? []].some((hostname) => {
@@ -607,8 +700,8 @@ function routePatternCouldIntersectCachePolicyRule(routePattern, rule, basePath)
 * request-specific next.config cache policy. The final Worker still evaluates
 * every concrete response before emitting public cache headers.
 */
-function annotateCacheabilityProbeSafety(routePatterns, config) {
-	const cachePolicyRules = config.headers.filter((rule) => rule.headers.some((header) => CACHEABILITY_POLICY_HEADER_NAMES.has(header.key.toLowerCase())));
+function annotateCacheabilityProbeSafety(routePatterns, config, routeMayResolve, requestStageMayTerminate, unlisted, isResponsePolicyHeader) {
+	const cachePolicyRules = config.headers.filter((rule) => rule.headers.some((header) => isResponsePolicyHeader(header.key)));
 	const matchingPolicyRules = new Map(Object.keys(routePatterns).map((pathname) => [pathname, new Set(cachePolicyRules.filter((rule) => cachePolicyRuleMatchesWarmPath(pathname, rule, config)))]));
 	const pathsByPattern = /* @__PURE__ */ new Map();
 	for (const [pathname, route] of Object.entries(routePatterns)) {
@@ -628,44 +721,82 @@ function annotateCacheabilityProbeSafety(routePatterns, config) {
 		const canPrunePattern = canPrunePatterns.get(patternKey) ?? false;
 		return [pathname, {
 			...route,
-			cacheabilityProbe: { canPrunePattern }
+			cacheabilityProbe: {
+				canPrunePattern,
+				...routeMayResolve.has(pathname) ? { routeMayResolve: true } : {},
+				...requestStageMayTerminate.has(pathname) ? { requestStageMayTerminate: true } : {},
+				...unlisted.has(pathname) ? { unlisted: true } : {}
+			}
 		}];
 	}));
 }
-function configuredRouteAffectsWarmPath(pathname, config) {
+function configuredRulesAffectWarmPath(pathname, rules, config) {
 	const canonicalPathname = normalizePathTrailingSlash(pathname, config.trailingSlash);
 	const hostnames = [void 0, ...config.i18n?.domains?.map((domain) => domain.domain) ?? []];
 	const matchPathnames = new Set(hostnames.map((hostname) => normalizeDefaultLocalePathname(canonicalPathname, config.i18n, { hostname })));
-	return [...[
-		...config.rewrites.beforeFiles,
-		...config.rewrites.afterFiles,
-		...config.rewrites.fallback
-	], ...config.redirects].some((rule) => Array.from(matchPathnames).some((matchPathname) => matchesRewriteSource(matchPathname, rule, {
+	return rules.some((rule) => Array.from(matchPathnames).some((matchPathname) => matchesRewriteSource(matchPathname, rule, {
 		basePath: config.basePath,
 		hadBasePath: true
 	})));
 }
+/**
+* Whether a configured rewrite can replace a route-owned warm response.
+* Non-dynamic filesystem routes win before `afterFiles`, while every concrete
+* path discovered here wins dynamic matching before `fallback`.
+*/
+function configuredRewritesCanReplaceWarmPath(pathname, rewrites, hasNonDynamicRoute, config, include) {
+	return configuredRulesAffectWarmPath(pathname, [...rewrites.beforeFiles.filter(include), ...hasNonDynamicRoute ? [] : rewrites.afterFiles.filter(include)], config);
+}
+function findMiddlewareConventionFile(root, appDir, pagesDir, pageExtensions) {
+	const routeDir = appDir ?? pagesDir;
+	const routeRoot = routeDir ? path.dirname(routeDir) : root;
+	const conventionDir = routeRoot === path.join(root, "src") ? routeRoot : root;
+	for (const name of ["proxy", "middleware"]) for (const extension of pageExtensions) {
+		const filePath = path.join(conventionDir, `${name}.${extension}`);
+		if (fs.existsSync(filePath)) return filePath;
+	}
+	return null;
+}
+/** @internal Match the pathname forms and locale provenance used by middleware runtime. */
+function matchesMiddlewareWarmPath(pathname, matcher, i18n) {
+	const encodedPathname = new URL(pathname, "https://vinext.invalid").pathname;
+	const firstSegment = encodedPathname.split("/", 3)[1]?.toLowerCase();
+	const localeContexts = i18n ? i18n.locales.some((locale) => locale.toLowerCase() === firstSegment) ? [{ kind: "literal" }] : Array.from(/* @__PURE__ */ new Set([i18n.defaultLocale, ...i18n.domains?.map((domain) => domain.defaultLocale) ?? []]), (defaultLocale) => ({
+		defaultLocale,
+		kind: "defaulted"
+	})) : [void 0];
+	const matchPathnames = [encodedPathname];
+	try {
+		const decodedPathname = decodeURIComponent(encodedPathname);
+		if (decodedPathname !== encodedPathname) matchPathnames.push(decodedPathname);
+	} catch {}
+	return matchPathnames.some((matchPathname) => localeContexts.some((localeContext) => matchesMiddlewarePathname(matchPathname, matcher, i18n, localeContext)));
+}
 async function startPathDiscoveryServer(options) {
 	return startProdServer({
 		port: 0,
 		host: "127.0.0.1",
 		outDir: options.pagesBundlePath ? path.dirname(path.dirname(options.pagesBundlePath)) : path.dirname(options.serverDir),
 		rscEntryPath: options.rscBundlePath,
+		serverDir: options.serverDir,
 		serverEntryPath: options.pagesBundlePath,
 		noCompression: true,
 		purpose: "prerender"
 	});
 }
-async function emitPrerenderPathManifest(options) {
+async function discoverPrerenderPathManifest(options) {
 	const { root } = options;
 	const configuredRouteDirs = resolveConfiguredRouteDirs(root, options.routeRootConfig);
 	const appDir = options.appDir !== void 0 ? options.appDir : configuredRouteDirs.appDir;
 	const pagesDir = options.pagesDir !== void 0 ? options.pagesDir : configuredRouteDirs.pagesDir;
 	if (!appDir && !pagesDir) return null;
-	const defaultRscBundlePath = options.routeRootConfig?.rscOutDir ? path.join(path.resolve(root, options.routeRootConfig.rscOutDir), "index.js") : path.join(root, "dist", "server", "index.js");
+	const configuredRscServerDir = options.routeRootConfig?.rscOutDir ? path.resolve(root, options.routeRootConfig.rscOutDir) : path.join(root, "dist", "server");
+	const defaultRscBundlePath = resolveBuiltRscEntryPath(configuredRscServerDir);
 	const rscBundlePath = options.rscBundlePath ?? defaultRscBundlePath;
+	const relativeRscEntryPath = path.relative(configuredRscServerDir, rscBundlePath);
+	const rscServerDir = !relativeRscEntryPath.startsWith("../") && !path.isAbsolute(relativeRscEntryPath) ? configuredRscServerDir : path.dirname(rscBundlePath);
 	const pagesBundlePath = options.pagesBundlePath ?? path.join(root, "dist", "server", "entry.js");
-	const bundleServerDir = fs.existsSync(rscBundlePath) ? path.dirname(rscBundlePath) : path.dirname(pagesBundlePath);
+	const bundleServerDir = fs.existsSync(rscBundlePath) ? rscServerDir : path.dirname(pagesBundlePath);
 	const manifestDir = path.join(root, "dist", "server");
 	const config = options.nextConfig ? { ...options.nextConfig } : { ...await resolveNextConfig(await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root) };
 	const builtBuildId = readBuiltBuildId(manifestDir) ?? readBuiltBuildId(bundleServerDir);
@@ -677,12 +808,11 @@ async function emitPrerenderPathManifest(options) {
 	const seenPagesPaths = /* @__PURE__ */ new Set();
 	const discoveredPagesDataPaths = [];
 	const seenPagesDataPaths = /* @__PURE__ */ new Set();
-	const discoveredAppPaths = [];
-	const seenAppPaths = /* @__PURE__ */ new Set();
 	const discoveredRouteHandlerPaths = [];
 	const seenRouteHandlerPaths = /* @__PURE__ */ new Set();
-	const discoveredLoadingShellPaths = [];
-	const seenLoadingShellPaths = /* @__PURE__ */ new Set();
+	const discoveredNonDynamicPathSet = /* @__PURE__ */ new Set();
+	const appListedRoutePaths = /* @__PURE__ */ new Set();
+	const candidateOnlyPathSet = /* @__PURE__ */ new Set();
 	const fallbackRoutePatterns = [];
 	await withPrerenderEndpoints(async () => {
 		let prodServer = null;
@@ -718,21 +848,22 @@ async function emitPrerenderPathManifest(options) {
 					appDir,
 					baseUrl,
 					cacheComponents: config.cacheComponents,
+					enumerateDynamicPaths: options.candidatePathsOnly !== true,
 					pageExtensions: config.pageExtensions,
 					retryOptions: pathDiscoveryRetryOptions,
+					root,
 					secretHeaders
 				});
-				for (const pathname of appPathResult.paths) {
-					addPath(paths, seen, pathname);
-					addPath(discoveredAppPaths, seenAppPaths, pathname);
-				}
-				for (const pathname of appPathResult.loadingShellPaths) addPath(discoveredLoadingShellPaths, seenLoadingShellPaths, pathname);
+				for (const pathname of appPathResult.paths) addPath(paths, seen, pathname);
 				for (const pathname of appPathResult.routeHandlerPaths) addPath(discoveredRouteHandlerPaths, seenRouteHandlerPaths, pathname);
+				for (const pathname of appPathResult.nonDynamicPaths) discoveredNonDynamicPathSet.add(pathname);
 				fallbackRoutePatterns.push(...appPathResult.fallbackRoutePatterns);
+				for (const key of appPathResult.listedRoutePaths) appListedRoutePaths.add(key);
 			}
 			if (pagesDir) {
 				const pagesPathResult = await collectPagesPaths({
 					baseUrl,
+					enumerateDynamicPaths: options.candidatePathsOnly !== true,
 					i18n: config.i18n,
 					pagesDir,
 					pageExtensions: config.pageExtensions,
@@ -744,13 +875,32 @@ async function emitPrerenderPathManifest(options) {
 					addPath(discoveredPagesPaths, seenPagesPaths, pathname);
 				}
 				for (const pathname of pagesPathResult.dataPaths) addPath(discoveredPagesDataPaths, seenPagesDataPaths, pathname);
+				for (const pathname of pagesPathResult.nonDynamicPaths) discoveredNonDynamicPathSet.add(pathname);
 				fallbackRoutePatterns.push(...pagesPathResult.fallbackRoutePatterns);
 			}
 		} finally {
 			if (prodServer) await new Promise((resolve) => prodServer.server.close(() => resolve()));
 		}
 	});
-	const excludedWarmPathSet = new Set(options.responseVary ? [...paths, ...discoveredRouteHandlerPaths].filter((pathname) => configuredRouteAffectsWarmPath(pathname, config)) : []);
+	for (const publicPathname of options.candidatePaths ?? []) {
+		let pathname = normalizePathTrailingSlash(new URL(publicPathname, "http://vinext.local").pathname, false);
+		if (config.basePath) {
+			if (pathname === config.basePath) pathname = "/";
+			else if (pathname.startsWith(`${config.basePath}/`)) pathname = pathname.slice(config.basePath.length);
+			else continue;
+		}
+		if (!seen.has(pathname)) candidateOnlyPathSet.add(pathname);
+		addPath(paths, seen, pathname);
+		if (pagesDir) addPath(discoveredPagesPaths, seenPagesPaths, pathname);
+	}
+	const hasStagedRequestRouting = options.requestRouting === "uncached-stage";
+	const middlewarePath = hasStagedRequestRouting ? findMiddlewareConventionFile(root, appDir, pagesDir, config.pageExtensions) : null;
+	const configuredMatcher = middlewarePath ? extractMiddlewareMatcherConfig(middlewarePath) : void 0;
+	const middlewareMayRouteWarmPath = (pathname) => middlewarePath !== null && matchesMiddlewareWarmPath(pathname, configuredMatcher, config.i18n);
+	const routedWarmPaths = [...paths, ...discoveredRouteHandlerPaths];
+	const routeMayResolveWarmPathSet = new Set(hasStagedRequestRouting ? routedWarmPaths.filter((pathname) => middlewareMayRouteWarmPath(pathname) || configuredRewritesCanReplaceWarmPath(pathname, config.rewrites, discoveredNonDynamicPathSet.has(pathname), config, (rewrite) => !isExternalUrl(rewrite.destination))) : []);
+	const requestStageMayTerminateWarmPathSet = new Set(hasStagedRequestRouting ? routedWarmPaths.filter((pathname) => middlewareMayRouteWarmPath(pathname) || configuredRulesAffectWarmPath(pathname, config.redirects, config) || configuredRewritesCanReplaceWarmPath(pathname, config.rewrites, discoveredNonDynamicPathSet.has(pathname), config, (rewrite) => isExternalUrl(rewrite.destination))) : []);
+	const excludedWarmPathSet = new Set(options.responseVary && !hasStagedRequestRouting ? routedWarmPaths.filter((pathname) => configuredRulesAffectWarmPath(pathname, config.redirects, config) || configuredRewritesCanReplaceWarmPath(pathname, config.rewrites, discoveredNonDynamicPathSet.has(pathname), config, () => true)) : []);
 	const configuredPagesWarmPaths = discoveredPagesPaths.filter((pathname) => !excludedWarmPathSet.has(pathname));
 	const resolvedPagesWarmPaths = !appDir && pagesDir ? await excludePagesApiWarmPaths({
 		i18n: config.i18n,
@@ -758,9 +908,20 @@ async function emitPrerenderPathManifest(options) {
 		pageExtensions: config.pageExtensions,
 		paths: configuredPagesWarmPaths
 	}) : configuredPagesWarmPaths;
-	const discoveredPagesDataPathSet = new Set(discoveredPagesDataPaths);
 	const configuredCandidatePaths = paths.filter((pathname) => !excludedWarmPathSet.has(pathname));
 	const configuredRouteHandlerPaths = discoveredRouteHandlerPaths.filter((pathname) => !excludedWarmPathSet.has(pathname));
+	const pagesWarmMetadata = pagesDir ? await resolvePagesWarmRouteMetadata({
+		i18n: config.i18n,
+		pagesDir,
+		pageExtensions: config.pageExtensions,
+		paths: resolvedPagesWarmPaths
+	}) : {
+		dataPaths: [],
+		routePatterns: {}
+	};
+	for (const pathname of pagesWarmMetadata.dataPaths) addPath(discoveredPagesDataPaths, seenPagesDataPaths, pathname);
+	const discoveredPagesDataPathSet = new Set(discoveredPagesDataPaths);
+	const pagesOnlyWarmPaths = resolvedPagesWarmPaths.filter((pathname) => pagesWarmMetadata.routePatterns[pathname] !== void 0);
 	const appOwnedWarmPaths = appDir ? await resolveAppWarmPaths({
 		appDir,
 		i18n: config.i18n,
@@ -770,22 +931,29 @@ async function emitPrerenderPathManifest(options) {
 	}) : {
 		appPaths: [],
 		appRoutePaths: [],
-		htmlPaths: discoveredAppPaths,
-		loadingShellPaths: discoveredLoadingShellPaths,
-		pagesPaths: resolvedPagesWarmPaths,
-		routePatterns: pagesDir ? await resolvePagesWarmRoutePatterns({
-			i18n: config.i18n,
-			pagesDir,
-			pageExtensions: config.pageExtensions,
-			paths: resolvedPagesWarmPaths
-		}) : {},
-		rscPaths: discoveredAppPaths
+		htmlPaths: pagesOnlyWarmPaths,
+		loadingBoundaryRoutePatterns: [],
+		loadingShellPaths: [],
+		pagesPaths: pagesOnlyWarmPaths,
+		routePatterns: pagesWarmMetadata.routePatterns,
+		rscPaths: []
 	};
-	const warmPaths = appDir ? appOwnedWarmPaths.htmlPaths : resolvedPagesWarmPaths;
-	const pagesOwnedWarmPaths = appDir ? appOwnedWarmPaths.pagesPaths : resolvedPagesWarmPaths;
+	for (const pathname of configuredCandidatePaths) {
+		if (appOwnedWarmPaths.routePatterns[pathname] || !routeMayResolveWarmPathSet.has(pathname) && !requestStageMayTerminateWarmPathSet.has(pathname)) continue;
+		appOwnedWarmPaths.htmlPaths.push(pathname);
+		(appDir ? appOwnedWarmPaths.appPaths : appOwnedWarmPaths.pagesPaths).push(pathname);
+		if (appDir && routeMayResolveWarmPathSet.has(pathname)) appOwnedWarmPaths.rscPaths.push(pathname);
+		appOwnedWarmPaths.routePatterns[pathname] = {
+			kind: appDir ? "app-page" : "pages-page",
+			pattern: pathname
+		};
+	}
+	const warmPaths = appOwnedWarmPaths.htmlPaths;
+	const pagesOwnedWarmPaths = appOwnedWarmPaths.pagesPaths;
 	const resolvedPagesDataWarmPaths = pagesOwnedWarmPaths.filter((pathname) => discoveredPagesDataPathSet.has(pathname));
 	const pagesDataPaths = resolvedPagesDataWarmPaths.map((pathname) => buildPagesDataHref(config.basePath, config.buildId, localizePagesDataPath(pathname, config.i18n), ""));
-	const routePatterns = annotateCacheabilityProbeSafety(appOwnedWarmPaths.routePatterns, config);
+	const unlistedPathSet = new Set(Object.entries(appOwnedWarmPaths.routePatterns).flatMap(([pathname, route]) => (route.kind === "app-page" ? !appListedRoutePaths.has(appPageListingKey(route.pattern, pathname)) : candidateOnlyPathSet.has(pathname)) ? [pathname] : []));
+	const routePatterns = annotateCacheabilityProbeSafety(appOwnedWarmPaths.routePatterns, config, routeMayResolveWarmPathSet, requestStageMayTerminateWarmPathSet, unlistedPathSet, (name) => name.trim().toLowerCase() === "cache-control" || options.isResponsePolicyHeader?.(name) === true);
 	for (let index = 0; index < resolvedPagesDataWarmPaths.length; index++) {
 		const route = routePatterns[resolvedPagesDataWarmPaths[index]];
 		if (route) {
@@ -799,6 +967,7 @@ async function emitPrerenderPathManifest(options) {
 			};
 		}
 	}
+	const includeCanonicalRsc = options.responseVary || options.includeCanonicalRsc;
 	const manifest = {
 		...appDir ? { appPaths: appOwnedWarmPaths.appPaths } : {},
 		...config.basePath ? { basePath: config.basePath } : {},
@@ -811,19 +980,26 @@ async function emitPrerenderPathManifest(options) {
 		} : {},
 		...excludedWarmPathSet.size > 0 ? { excludedWarmPaths: Array.from(excludedWarmPathSet) } : {},
 		...fallbackRoutePatterns.length > 0 ? { fallbackRoutePatterns } : {},
+		...appOwnedWarmPaths.loadingBoundaryRoutePatterns.length > 0 ? { loadingBoundaryRoutePatterns: appOwnedWarmPaths.loadingBoundaryRoutePatterns } : {},
 		...rscBuildId ? { rscBuildId } : {},
 		...options.responseVary ? { responseVary: options.responseVary } : {},
-		...options.responseVary ? { rscPaths: appOwnedWarmPaths.rscPaths } : {},
+		...includeCanonicalRsc ? { rscPaths: appOwnedWarmPaths.rscPaths } : {},
 		...Object.keys(routePatterns).length > 0 ? { routePatterns } : {},
 		...appOwnedWarmPaths.appRoutePaths.length > 0 ? { routeHandlerPaths: appOwnedWarmPaths.appRoutePaths } : {},
-		...options.responseVary ? { loadingShellPaths: appOwnedWarmPaths.loadingShellPaths } : {},
+		...includeCanonicalRsc ? { loadingShellPaths: appOwnedWarmPaths.loadingShellPaths } : {},
 		trailingSlash: config.trailingSlash,
 		paths: warmPaths
 	};
+	console.log(`  Discovered ${warmPaths.length + appOwnedWarmPaths.appRoutePaths.length} CDN warmup path(s).`);
+	return manifest;
+}
+async function emitPrerenderPathManifest(options) {
+	const manifest = await discoverPrerenderPathManifest(options);
+	if (!manifest) return null;
+	const manifestDir = path.join(options.root, "dist", "server");
 	fs.mkdirSync(manifestDir, { recursive: true });
 	fs.writeFileSync(path.join(manifestDir, PRERENDER_PATHS_MANIFEST), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
-	console.log(`  Discovered ${warmPaths.length + appOwnedWarmPaths.appRoutePaths.length} CDN warmup path(s).`);
 	return manifest;
 }
 //#endregion
-export { DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS, DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS, PRERENDER_PATHS_MANIFEST, PRERENDER_PATH_DISCOVERY_ENV, emitPrerenderPathManifest };
+export { DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS, DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS, PRERENDER_PATHS_MANIFEST, PRERENDER_PATH_DISCOVERY_ENV, discoverPrerenderPathManifest, emitPrerenderPathManifest, matchesMiddlewareWarmPath };