vinext 1.0.0-beta.8 → 1.0.0

package/dist/build/prerender-paths.js

@@ -1,21 +1,45 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { findDir } from "../utils/project.js";
-import { apiRouter, pagesRouter } from "../routing/pages-router.js";
-import { VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
-import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath, hasNamedExport } from "./report.js";
-import { appRouter } from "../routing/app-router.js";
-import { normalizeStaticPathsEntry } from "../routing/route-pattern.js";
 import { BLOCKED_PAGES, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
+import { VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
+import { isExternalUrl } from "../utils/external-url.js";
+import { matchHeaders, matchesRewriteSource } from "../config/config-matchers.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 { 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 { 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";
 const PRERENDER_PATHS_MANIFEST = "vinext-prerender-paths.json";
 const PATH_DISCOVERY_FETCH_TIMEOUT_MS = 3e4;
+const DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS = 1e3;
+const DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS = 12e4;
+function readDiscoveryUserFailure(response, text) {
+	if (response.status !== 500 || !response.headers.get("content-type")?.includes("application/json")) return null;
+	try {
+		const value = JSON.parse(text);
+		if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+		const error = value.error;
+		return typeof error === "string" && error.length > 0 ? error : null;
+	} catch {
+		return null;
+	}
+}
 function readBuiltBuildId(serverDir) {
 	try {
 		const buildId = fs.readFileSync(path.join(serverDir, "BUILD_ID"), "utf-8").trim();
@@ -25,40 +49,131 @@ function readBuiltBuildId(serverDir) {
 		throw error;
 	}
 }
+function readBuiltRscBuildId(serverDir) {
+	try {
+		const buildId = fs.readFileSync(path.join(serverDir, "RSC_BUILD_ID"), "utf-8").trim();
+		return buildId.length > 0 ? buildId : null;
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
 function addPath(paths, seen, pathname) {
 	if (seen.has(pathname)) return;
 	seen.add(pathname);
 	paths.push(pathname);
 }
-function warnDiscoveryFailure(route, error) {
+function throwDiscoveryFailure(route, error) {
 	const message = error instanceof Error ? error.message : String(error);
-	console.warn(`[vinext] Warning: failed to discover warmup path(s) for ${route}: ${message}`);
+	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 });
 }
-async function fetchDiscoveryEndpoint(url, headers) {
-	const controller = new AbortController();
-	const timeout = setTimeout(() => controller.abort(), PATH_DISCOVERY_FETCH_TIMEOUT_MS);
-	try {
-		const res = await fetch(url, {
-			headers,
-			signal: controller.signal
-		});
-		const text = await res.text();
-		if (!res.ok || text === "null") return null;
-		return text;
-	} catch (error) {
-		if (error instanceof Error && error.name === "AbortError") throw new Error(`path discovery timed out after ${PATH_DISCOVERY_FETCH_TIMEOUT_MS}ms`);
-		throw error;
-	} finally {
-		clearTimeout(timeout);
+function validatePagesStaticPathsResult(value, route) {
+	const expected = "Expected { paths: [], fallback: boolean | 'blocking' }.";
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid value returned from getStaticPaths for ${route}. ${expected}`);
+	const result = value;
+	const extraKeys = Object.keys(result).filter((key) => key !== "paths" && key !== "fallback");
+	if (extraKeys.length > 0) throw new Error(`Extra key(s) returned from getStaticPaths for ${route}: ${extraKeys.join(", ")}. ${expected}`);
+	if (typeof result.fallback !== "boolean" && result.fallback !== "blocking") throw new Error(`Invalid fallback returned from getStaticPaths for ${route}. ${expected}`);
+	if (!Array.isArray(result.paths)) throw new Error(`Invalid paths returned from getStaticPaths for ${route}; paths must be an array.`);
+	return {
+		fallback: result.fallback,
+		paths: result.paths
+	};
+}
+function hasUnsafeRawUrlPathCharacter(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code === 92 || code <= 31 || code === 127) return true;
 	}
+	return false;
 }
-function fileHasNamedExport(filePath, name) {
-	if (!filePath) return false;
-	try {
-		return hasNamedExport(fs.readFileSync(filePath, "utf-8"), name);
-	} catch {
-		return false;
+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}\`.`);
+		let decodedSegments;
+		try {
+			decodedSegments = entry.split("/").map((segment) => decodeURIComponent(segment));
+		} catch {
+			throw new Error(`The provided path \`${entry}\` from getStaticPaths contains malformed percent-encoding.`);
+		}
+		if (decodedSegments.some((segment) => segment === "." || segment === "..")) throw new Error(`The provided path \`${entry}\` from getStaticPaths contains a dot path segment.`);
+		return entry;
 	}
+	if (!entry || typeof entry !== "object" || Array.isArray(entry)) return entry;
+	const extraKeys = Object.keys(entry).filter((key) => key !== "params" && key !== "locale");
+	if (extraKeys.length > 0) throw new Error(`Additional key(s) returned from getStaticPaths for ${pattern}: ${extraKeys.join(", ")}.`);
+	if (entry.locale !== void 0 && typeof entry.locale !== "string") throw new Error(`Invalid locale returned from getStaticPaths for ${pattern}.`);
+	return {
+		...entry,
+		params: validateDiscoveredParams(entry.params, pattern, "getStaticPaths")
+	};
+}
+async function fetchDiscoveryEndpoint(url, headers, retryOptions = {}) {
+	const hasSharedPhaseDeadline = retryOptions.deadlineAt !== void 0;
+	const retryDelayMs = Math.max(0, retryOptions.retryDelayMs ?? (hasSharedPhaseDeadline ? 1e3 : 0));
+	const phaseTimeoutMs = Math.max(1, retryOptions.phaseTimeoutMs ?? 12e4);
+	const retryBudgetDelayMs = retryDelayMs > 0 ? retryDelayMs : DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS;
+	const retries = Math.max(0, retryOptions.retries ?? (hasSharedPhaseDeadline ? Math.ceil(phaseTimeoutMs / retryBudgetDelayMs) : 0));
+	const deadlineAt = retryOptions.deadlineAt ?? Date.now() + phaseTimeoutMs;
+	let lastError;
+	let attemptsRun = 0;
+	let lastTransientStatus;
+	const attemptSummary = () => ` after ${attemptsRun} attempt(s)${lastTransientStatus === void 0 ? "" : `; last transient status was HTTP ${lastTransientStatus}`}`;
+	const phaseTimeoutError = () => /* @__PURE__ */ new Error(`remote path discovery exceeded its ${phaseTimeoutMs}ms phase deadline${attemptSummary()}`);
+	for (let attempt = 0; attempt <= retries; attempt++) {
+		const remainingMs = deadlineAt - Date.now();
+		if (remainingMs <= 0) throw phaseTimeoutError();
+		attemptsRun++;
+		const controller = new AbortController();
+		const attemptTimeoutMs = Math.min(PATH_DISCOVERY_FETCH_TIMEOUT_MS, remainingMs);
+		let timeout;
+		let shouldRetry = true;
+		try {
+			const request = (async () => {
+				const res = await fetch(url, {
+					headers,
+					signal: controller.signal
+				});
+				return {
+					res,
+					text: await res.text()
+				};
+			})();
+			const timedOut = new Promise((_resolve, reject) => {
+				timeout = setTimeout(() => {
+					controller.abort();
+					reject(new DOMException(`Timed out after ${attemptTimeoutMs}ms`, "AbortError"));
+				}, attemptTimeoutMs);
+			});
+			const { res, text } = await Promise.race([request, timedOut]);
+			if (res.ok) {
+				if (res.status === 204) return null;
+				return text;
+			}
+			const userFailure = readDiscoveryUserFailure(res, text);
+			const detail = userFailure ?? (/cloudflare:|ERR_UNSUPPORTED_ESM_URL_SCHEME/i.test(text) ? text.trim() : "");
+			lastError = /* @__PURE__ */ new Error(`path discovery returned HTTP ${res.status}${detail ? `: ${detail}` : ""}`);
+			if (!(res.status === 404 || res.status >= 500 && res.status <= 599 && userFailure === null)) {
+				shouldRetry = false;
+				throw lastError;
+			}
+			lastTransientStatus = res.status;
+		} catch (error) {
+			if (Date.now() >= deadlineAt) throw phaseTimeoutError();
+			lastError = error instanceof Error && error.name === "AbortError" ? /* @__PURE__ */ new Error(`path discovery timed out after ${attemptTimeoutMs}ms`) : error;
+			if (!shouldRetry) throw lastError;
+		} finally {
+			if (timeout !== void 0) clearTimeout(timeout);
+		}
+		if (attempt < retries && retryDelayMs > 0) {
+			const delayMs = Math.min(retryDelayMs, Math.max(0, deadlineAt - Date.now()));
+			if (delayMs <= 0) throw phaseTimeoutError();
+			await new Promise((resolve) => setTimeout(resolve, delayMs));
+		}
+	}
+	const message = lastError instanceof Error ? lastError.message : String(lastError);
+	throw new Error(`${message}${attemptSummary()}`, { cause: lastError });
 }
 function resolveConfiguredRouteDirs(root, routeRootConfig) {
 	if (!routeRootConfig) return {
@@ -83,16 +198,12 @@ function resolveConfiguredRouteDirs(root, routeRootConfig) {
 		pagesDir: fs.existsSync(pagesDir) ? pagesDir : null
 	};
 }
-function appRouteMayHaveGenerateStaticParams(route) {
-	if (fileHasNamedExport(route.pagePath, "generateStaticParams")) return true;
-	return route.layouts.some((layoutPath) => fileHasNamedExport(layoutPath, "generateStaticParams"));
-}
 async function shouldStartPathDiscoveryServer(options) {
 	if (options.appDir) {
-		if ((await appRouter(options.appDir, options.pageExtensions)).some((route) => route.isDynamic && appRouteMayHaveGenerateStaticParams(route))) return true;
+		if ((await appRouter(options.appDir, options.pageExtensions)).some((route) => route.isDynamic)) return true;
 	}
 	if (options.pagesDir) {
-		if ((await pagesRouter(options.pagesDir, options.pageExtensions)).some((route) => route.isDynamic && fileHasNamedExport(route.filePath, "getStaticPaths"))) return true;
+		if ((await pagesRouter(options.pagesDir, options.pageExtensions)).some((route) => route.isDynamic)) return true;
 	}
 	return false;
 }
@@ -113,73 +224,294 @@ async function collectPagesPaths(options) {
 	const apiPatterns = new Set(apiRoutes.map((route) => route.pattern));
 	const paths = [];
 	const seen = /* @__PURE__ */ new Set();
+	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;
 		if (route.pattern === "/404" || route.pattern === "/500" || route.pattern === "/_error") continue;
-		const { type } = classifyPagesRoute(route.filePath);
-		if (type === "api" || type === "ssr") continue;
+		const { hasServerSideProps, hasStaticProps, type } = classifyPagesRoute(route.filePath);
+		if (type === "api") continue;
 		if (!route.isDynamic) {
-			addPath(paths, seen, route.pattern);
+			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 (!fileHasNamedExport(route.filePath, "getStaticPaths")) continue;
+		if (!options.enumerateDynamicPaths) continue;
+		if (type === "ssr") continue;
 		if (!options.baseUrl) continue;
 		try {
 			const search = new URLSearchParams({ pattern: route.pattern });
-			const text = await fetchDiscoveryEndpoint(`${options.baseUrl}/__vinext/prerender/pages-static-paths?${search}`, options.secretHeaders);
+			if (options.i18n) {
+				search.set("locales", JSON.stringify(options.i18n.locales));
+				search.set("defaultLocale", options.i18n.defaultLocale);
+			}
+			const text = await fetchDiscoveryEndpoint(`${options.baseUrl}/__vinext/prerender/pages-static-paths?${search}`, options.secretHeaders, options.retryOptions);
 			if (text === null) continue;
-			const pathsResult = JSON.parse(text);
-			for (const item of pathsResult.paths ?? []) {
-				const normalized = normalizeStaticPathsEntry(item, route.pattern);
+			const pathsResult = validatePagesStaticPathsResult(JSON.parse(text), route.pattern);
+			if (pathsResult.fallback !== false) fallbackRoutePatterns.push({
+				kind: "pages-page",
+				pattern: route.pattern
+			});
+			for (const item of pathsResult.paths) {
+				const validatedItem = validatePagesStaticPathsEntry(item, route.pattern);
+				let itemToNormalize = validatedItem;
+				let locale = options.i18n?.defaultLocale;
+				if (options.i18n && typeof validatedItem === "string") itemToNormalize = extractPagesStaticPathLocale(validatedItem, options.i18n).url;
+				else if (options.i18n && validatedItem && typeof validatedItem === "object" && validatedItem.locale) {
+					if (!options.i18n.locales.includes(validatedItem.locale)) throw new Error(`Invalid locale returned from getStaticPaths for ${route.pattern}: ${validatedItem.locale}`);
+					locale = validatedItem.locale;
+				}
+				const normalized = normalizeStaticPathsEntry(itemToNormalize, route.pattern);
 				if ("error" in normalized) throw new Error(normalized.error);
-				addPath(paths, seen, buildUrlFromParams(route.pattern, normalized.params));
+				const pathname = typeof validatedItem === "string" ? normalizeStaticPathname(validatedItem) : localizePagesPath(buildUrlFromParams(route.pattern, normalized.params), locale, options.i18n);
+				addPath(paths, seen, pathname);
+				if (hasStaticProps) addPath(dataPaths, seenDataPaths, pathname);
 			}
 		} catch (error) {
-			warnDiscoveryFailure(route.pattern, error);
+			throwDiscoveryFailure(route.pattern, error);
+		}
+	}
+	return {
+		dataPaths,
+		fallbackRoutePatterns,
+		nonDynamicPaths,
+		paths
+	};
+}
+async function excludePagesApiWarmPaths(options) {
+	const apiRoutes = await apiRouter(options.pagesDir, options.pageExtensions);
+	return options.paths.filter((pathname) => {
+		const pagesPathname = options.i18n ? extractLocaleFromUrl(pathname, options.i18n).url : pathname;
+		if (pagesPathname !== "/api" && !pagesPathname.startsWith("/api/")) return true;
+		return matchRoute(pagesPathname, apiRoutes) === null;
+	});
+}
+async function resolvePagesWarmRouteMetadata(options) {
+	const pageRoutes = await pagesRouter(options.pagesDir, options.pageExtensions);
+	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 paths;
+	return {
+		dataPaths,
+		routePatterns
+	};
+}
+function localizePagesPath(pathname, locale, i18n) {
+	if (!i18n || !locale || locale === i18n.defaultLocale) return pathname;
+	return pathname === "/" ? `/${locale}` : `/${locale}${pathname}`;
+}
+/**
+* Next.js data URLs always carry the locale segment, including the default
+* locale that is omitted from the corresponding public HTML pathname.
+*
+* Ported from Next.js:
+* packages/next/src/shared/lib/router/utils/format-next-pathname-info.ts
+*/
+function localizePagesDataPath(pathname, i18n) {
+	if (!i18n) return pathname;
+	if (extractPagesStaticPathLocale(pathname, i18n).explicitLocalePrefix) return pathname;
+	return pathname === "/" ? `/${i18n.defaultLocale}` : `/${i18n.defaultLocale}${pathname}`;
+}
+function extractPagesStaticPathLocale(url, i18n) {
+	const queryIndex = url.indexOf("?");
+	const pathname = queryIndex === -1 ? url : url.slice(0, queryIndex);
+	const query = queryIndex === -1 ? "" : url.slice(queryIndex);
+	const parts = pathname.split("/").filter(Boolean);
+	const locale = parts.length > 0 ? i18n.locales.find((candidate) => candidate.toLowerCase() === parts[0].toLowerCase()) : void 0;
+	if (!locale) return extractLocaleFromUrl(url, i18n);
+	const rest = `/${parts.slice(1).join("/")}`;
+	return {
+		explicitLocalePrefix: parts[0],
+		locale,
+		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 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 cached = staticParamsCache.get(cacheKey);
-				if (cached !== void 0) return cached;
-				const request = (async () => {
-					const search = new URLSearchParams({ pattern });
-					if (Object.keys(params).length > 0) search.set("parentParams", JSON.stringify(params));
-					const text = await fetchDiscoveryEndpoint(`${options.baseUrl}/__vinext/prerender/static-params?${search}`, options.secretHeaders);
-					if (text === null) return null;
-					return JSON.parse(text);
-				})();
-				request.catch(() => staticParamsCache.delete(cacheKey));
-				staticParamsCache.set(cacheKey, request);
-				return request;
+				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);
+						if (!Array.isArray(value)) throw new Error(`generateStaticParams must return an array for ${pattern}.`);
+						return value.map((entry) => {
+							if (!entry || typeof entry !== "object" || Array.isArray(entry)) throw new Error(`generateStaticParams must return parameter objects for ${pattern}.`);
+							return validateDiscoveredParams({
+								...params,
+								...entry
+							}, pattern, "generateStaticParams");
+						});
+					})();
+					request.catch(() => staticParamsCache.delete(cacheKey));
+					staticParamsCache.set(cacheKey, request);
+				}
+				const value = await request;
+				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;
 			};
 		},
 		has() {
 			return false;
 		}
 	});
+	const readMdxEsm = !options.cacheComponents && options.pageExtensions.includes("mdx") ? await loadMdxEsmReader(options.root) : null;
 	for (const route of routes) {
-		const renderEntryPath = getAppRouteRenderEntryPath(route);
+		const isRouteHandler = route.routePath !== null && route.pagePath === null;
+		const renderEntryPath = isRouteHandler ? route.routePath : getAppRouteRenderEntryPath(route);
 		if (!renderEntryPath) continue;
-		const { type } = classifyAppRoute(renderEntryPath, route.routePath, route.isDynamic);
-		if (type === "api") continue;
-		if (type === "ssr" && !route.isDynamic) continue;
+		if (isRouteHandler) {
+			const classification = classifyAppRouteHandler(route.routePath);
+			if (!classification.hasGet || !classification.staticGenerationEnabled) continue;
+		} else {
+			const { type } = classifyAppRoute(renderEntryPath, route.routePath, route.isDynamic);
+			if (type === "api") continue;
+		}
+		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 (isStaticEligible) listedRoutePaths.add(appPageListingKey(route.pattern, pathname));
+		};
 		if (!route.isDynamic) {
-			addPath(paths, seen, route.pattern);
+			addDiscoveredPath(route.pattern);
+			addPath(nonDynamicPaths, seenNonDynamicPaths, route.pattern);
 			continue;
 		}
-		if (!appRouteMayHaveGenerateStaticParams(route)) continue;
+		if (!options.enumerateDynamicPaths) continue;
+		requireNonEmptyStaticParams = options.cacheComponents && !isRouteHandler;
 		try {
 			const generateStaticParams = staticParamsMap[route.pattern];
 			if (typeof generateStaticParams !== "function") continue;
@@ -190,28 +522,255 @@ 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: {} });
-				paramSets = Array.isArray(results) || results === null ? results : [];
+				paramSets = results === null ? null : routeStaticParamSets(route, Array.isArray(results) ? results : []);
+			}
+			if (!paramSets?.length) {
+				if (isRouteHandler) {
+					const dynamicConfig = extractExportConstString(fs.readFileSync(renderEntryPath, "utf8"), "dynamic");
+					if (paramSets !== null || dynamicConfig === "force-static" || dynamicConfig === "error") fallbackRoutePatterns.push({
+						kind: "app-route",
+						pattern: route.pattern
+					});
+					continue;
+				}
+				const parallelSegments = route.parallelSlots.flatMap((slot) => [
+					slot.layoutPath,
+					...slot.configLayoutPaths ?? [],
+					slot.pagePath ?? slot.defaultPath
+				].filter((filePath) => typeof filePath === "string"));
+				const hasDynamicSegment = [
+					...route.layouts,
+					renderEntryPath,
+					...parallelSegments
+				].map((filePath) => classifyAppRoute(filePath, null, false)).some((classification) => classification.type === "ssr");
+				const readDynamicConfig = (filePath) => {
+					const dynamic = extractExportConstString(fs.readFileSync(filePath, "utf8"), "dynamic");
+					return dynamic === null ? {} : { dynamic };
+				};
+				const dynamicConfig = resolveAppPageDynamicConfig({
+					layouts: route.layouts.map(readDynamicConfig),
+					page: readDynamicConfig(renderEntryPath),
+					parallelSegments: parallelSegments.map(readDynamicConfig)
+				});
+				if ((paramSets !== null || dynamicConfig === "force-static" || dynamicConfig === "error") && !hasDynamicSegment && staticEligibility === "eligible") fallbackRoutePatterns.push({
+					kind: "app-page",
+					pattern: route.pattern
+				});
+				continue;
 			}
-			if (!paramSets?.length) continue;
 			for (const params of paramSets) {
 				if (params === null || params === void 0) continue;
-				addPath(paths, seen, buildUrlFromParams(route.pattern, params));
+				addDiscoveredPath(buildUrlFromParams(route.pattern, params));
 			}
 		} catch (error) {
-			warnDiscoveryFailure(route.pattern, error);
+			throwDiscoveryFailure(route.pattern, error);
+		}
+	}
+	return {
+		fallbackRoutePatterns,
+		nonDynamicPaths,
+		paths,
+		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 = [];
+	const appPaths = [];
+	const appRoutePaths = [];
+	const htmlPaths = [];
+	const loadingShellPaths = [];
+	const pagesPaths = [];
+	const routePatterns = {};
+	for (const pathname of options.paths) {
+		const appMatch = matchAppRoute(pathname, appRoutes);
+		const pagesPathname = options.i18n ? extractLocaleFromUrl(pathname, options.i18n).url : pathname;
+		const isPagesApiRequest = pathname === "/api" || pathname.startsWith("/api/");
+		const pagesMatch = matchRoute(pagesPathname, isPagesApiRequest ? apiRoutes : pageRoutes);
+		if (pagesMatch && (!appMatch || pagesRouteHasPriorityOverAppRoute(pagesMatch.route, appMatch.route))) {
+			if (!isPagesApiRequest) {
+				htmlPaths.push(pathname);
+				pagesPaths.push(pathname);
+				routePatterns[pathname] = {
+					kind: "pages-page",
+					pattern: pagesMatch.route.pattern
+				};
+			}
+			continue;
+		}
+		if (!appMatch) continue;
+		const matchedAppRoute = appMatch.route;
+		if (matchedAppRoute.routePath && !matchedAppRoute.pagePath) {
+			const classification = routeHandlerClassifications.get(matchedAppRoute.routePath);
+			if (classification?.hasGet && classification.staticGenerationEnabled) {
+				appRoutePaths.push(pathname);
+				routePatterns[pathname] = {
+					kind: "app-route",
+					pattern: matchedAppRoute.pattern
+				};
+			}
+			continue;
 		}
+		const appRenderEntryPath = getAppRouteRenderEntryPath(matchedAppRoute);
+		if (!appRenderEntryPath) continue;
+		if (classifyAppRoute(appRenderEntryPath, matchedAppRoute.routePath, matchedAppRoute.isDynamic).type === "api") continue;
+		appPaths.push(pathname);
+		htmlPaths.push(pathname);
+		rscPaths.push(pathname);
+		routePatterns[pathname] = {
+			kind: "app-page",
+			pattern: matchedAppRoute.pattern
+		};
+		if (appRouteHasMainTreeLoadingBoundary(matchedAppRoute)) loadingShellPaths.push(pathname);
+	}
+	return {
+		appPaths,
+		appRoutePaths,
+		htmlPaths,
+		loadingBoundaryRoutePatterns,
+		loadingShellPaths,
+		pagesPaths,
+		routePatterns,
+		rscPaths
+	};
+}
+function cachePolicyRuleMatchesWarmPath(pathname, rule, config) {
+	const canonicalPathname = normalizePathTrailingSlash(pathname, config.trailingSlash);
+	return [void 0, ...config.i18n?.domains?.map((domain) => domain.domain) ?? []].some((hostname) => {
+		const matchPathname = normalizeDefaultLocalePathname(canonicalPathname, config.i18n, { hostname });
+		let sourceMatched = false;
+		matchHeaders(matchPathname, [rule], {
+			cookies: {},
+			headers: new Headers(),
+			host: hostname ?? "",
+			query: new URLSearchParams()
+		}, {
+			basePath: config.basePath,
+			hadBasePath: true
+		}, () => {
+			sourceMatched = true;
+		});
+		return sourceMatched;
+	});
+}
+function cachePolicyRuleSourceMatchesWarmPath(pathname, rule, config) {
+	return cachePolicyRuleMatchesWarmPath(pathname, {
+		...rule,
+		has: void 0,
+		missing: void 0
+	}, config);
+}
+function staticConfigPatternSegments(pattern) {
+	const segments = [];
+	for (const segment of pattern.split("/").filter(Boolean)) {
+		if (/[:*()[\]{}]/.test(segment)) break;
+		segments.push(segment);
+	}
+	return segments;
+}
+function routePatternCouldIntersectCachePolicyRule(routePattern, rule, basePath) {
+	let ruleSource = rule.source;
+	if (rule.basePath !== false && basePath && (ruleSource === basePath || ruleSource.startsWith(`${basePath}/`))) ruleSource = ruleSource.slice(basePath.length) || "/";
+	const routeSegments = staticConfigPatternSegments(routePattern);
+	const ruleSegments = staticConfigPatternSegments(ruleSource);
+	const sharedLength = Math.min(routeSegments.length, ruleSegments.length);
+	for (let index = 0; index < sharedLength; index++) if (routeSegments[index] !== ruleSegments[index]) return false;
+	return true;
+}
+/**
+* Certify only route-config bailouts that cannot hide a path- or
+* request-specific next.config cache policy. The final Worker still evaluates
+* every concrete response before emitting public cache headers.
+*/
+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)) {
+		const key = `${route.kind}\0${route.pattern}`;
+		const paths = pathsByPattern.get(key) ?? [];
+		paths.push(pathname);
+		pathsByPattern.set(key, paths);
 	}
-	return paths;
+	const canPrunePatterns = /* @__PURE__ */ new Map();
+	for (const [patternKey, patternPaths] of pathsByPattern) {
+		const routePattern = routePatterns[patternPaths[0]].pattern;
+		const relevantRules = cachePolicyRules.filter((rule) => patternPaths.some((path) => cachePolicyRuleSourceMatchesWarmPath(path, rule, config)) || routePatternCouldIntersectCachePolicyRule(routePattern, rule, config.basePath));
+		canPrunePatterns.set(patternKey, relevantRules.every((rule) => !rule.has?.length && !rule.missing?.length && patternPaths.every((path) => matchingPolicyRules.get(path)?.has(rule) === true)));
+	}
+	return Object.fromEntries(Object.entries(routePatterns).map(([pathname, route]) => {
+		const patternKey = `${route.kind}\0${route.pattern}`;
+		const canPrunePattern = canPrunePatterns.get(patternKey) ?? false;
+		return [pathname, {
+			...route,
+			cacheabilityProbe: {
+				canPrunePattern,
+				...routeMayResolve.has(pathname) ? { routeMayResolve: true } : {},
+				...requestStageMayTerminate.has(pathname) ? { requestStageMayTerminate: true } : {},
+				...unlisted.has(pathname) ? { unlisted: true } : {}
+			}
+		}];
+	}));
+}
+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 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({
@@ -219,34 +778,50 @@ async function startPathDiscoveryServer(options) {
 		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);
+	const rscBuildId = readBuiltRscBuildId(manifestDir) ?? readBuiltRscBuildId(bundleServerDir);
 	if (builtBuildId) config.buildId = builtBuildId;
 	const paths = [];
 	const seen = /* @__PURE__ */ new Set();
+	const discoveredPagesPaths = [];
+	const seenPagesPaths = /* @__PURE__ */ new Set();
+	const discoveredPagesDataPaths = [];
+	const seenPagesDataPaths = /* @__PURE__ */ new Set();
+	const discoveredRouteHandlerPaths = [];
+	const seenRouteHandlerPaths = /* @__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;
-		if (await shouldStartPathDiscoveryServer({
+		const needsServer = await shouldStartPathDiscoveryServer({
 			appDir,
 			pagesDir,
 			pageExtensions: config.pageExtensions
-		})) try {
+		});
+		if (needsServer && !options.pathDiscoveryTarget) try {
 			prodServer = await startPathDiscoveryServer({
 				serverDir: bundleServerDir,
 				pagesBundlePath: !appDir && pagesDir ? pagesBundlePath : void 0,
@@ -254,37 +829,177 @@ async function emitPrerenderPathManifest(options) {
 			});
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			console.warn(`[vinext] Warning: failed to start prerender path discovery server: ${message}`);
+			throw new Error(`Failed to start prerender path discovery server: ${message}`, { cause: error });
 		}
-		const baseUrl = prodServer ? `http://127.0.0.1:${prodServer.port}` : null;
+		const baseUrl = options.pathDiscoveryTarget?.baseUrl ? new URL(options.pathDiscoveryTarget.baseUrl).origin : prodServer ? `http://127.0.0.1:${prodServer.port}` : null;
 		const prerenderSecret = readPrerenderSecret(bundleServerDir) ?? readPrerenderSecret(manifestDir);
-		const secretHeaders = prerenderSecret ? { [VINEXT_PRERENDER_SECRET_HEADER]: prerenderSecret } : {};
+		if (needsServer && options.pathDiscoveryTarget && !prerenderSecret) throw new Error("Cannot discover warmup paths from the staged Worker because dist/server/vinext-server.json does not contain a prerender secret. Rebuild the app before deploying.");
+		const secretHeaders = Object.fromEntries(new Headers(options.pathDiscoveryTarget?.headers));
+		if (prerenderSecret) secretHeaders[VINEXT_PRERENDER_SECRET_HEADER] = prerenderSecret;
+		const pathDiscoveryRetryOptions = options.pathDiscoveryTarget ? {
+			deadlineAt: Date.now() + Math.max(1, options.pathDiscoveryTarget.phaseTimeoutMs ?? 12e4),
+			phaseTimeoutMs: options.pathDiscoveryTarget.phaseTimeoutMs,
+			retries: options.pathDiscoveryTarget.retries,
+			retryDelayMs: options.pathDiscoveryTarget.retryDelayMs
+		} : void 0;
 		try {
-			if (appDir) for (const pathname of await collectAppPaths({
-				appDir,
-				baseUrl,
-				pageExtensions: config.pageExtensions,
-				secretHeaders
-			})) addPath(paths, seen, pathname);
-			if (pagesDir) for (const pathname of await collectPagesPaths({
-				baseUrl,
-				pagesDir,
-				pageExtensions: config.pageExtensions,
-				secretHeaders
-			})) addPath(paths, seen, pathname);
+			if (appDir) {
+				const appPathResult = await collectAppPaths({
+					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);
+				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,
+					retryOptions: pathDiscoveryRetryOptions,
+					secretHeaders
+				});
+				for (const pathname of pagesPathResult.paths) {
+					addPath(paths, seen, pathname);
+					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()));
 		}
 	});
+	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,
+		pagesDir,
+		pageExtensions: config.pageExtensions,
+		paths: configuredPagesWarmPaths
+	}) : configuredPagesWarmPaths;
+	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,
+		pagesDir,
+		pageExtensions: config.pageExtensions,
+		paths: [...configuredCandidatePaths, ...configuredRouteHandlerPaths]
+	}) : {
+		appPaths: [],
+		appRoutePaths: [],
+		htmlPaths: pagesOnlyWarmPaths,
+		loadingBoundaryRoutePatterns: [],
+		loadingShellPaths: [],
+		pagesPaths: pagesOnlyWarmPaths,
+		routePatterns: pagesWarmMetadata.routePatterns,
+		rscPaths: []
+	};
+	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 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) {
+			const htmlPathname = resolvedPagesDataWarmPaths[index] === "/" ? config.basePath || "/" : `${config.basePath}${resolvedPagesDataWarmPaths[index]}`;
+			routePatterns[pagesDataPaths[index]] = {
+				...route,
+				cacheabilityProbe: {
+					...route.cacheabilityProbe,
+					concretePathname: htmlPathname
+				}
+			};
+		}
+	}
+	const includeCanonicalRsc = options.responseVary || options.includeCanonicalRsc;
 	const manifest = {
+		...appDir ? { appPaths: appOwnedWarmPaths.appPaths } : {},
+		...config.basePath ? { basePath: config.basePath } : {},
 		buildId: config.buildId,
+		...rscBuildId && options.buildIdentity === "response-header" ? { buildIdentity: rscBuildId } : {},
+		...config.deploymentId ? { deploymentId: config.deploymentId } : {},
+		...pagesDir ? {
+			pagesDataPaths,
+			pagesPaths: pagesOwnedWarmPaths
+		} : {},
+		...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 } : {},
+		...includeCanonicalRsc ? { rscPaths: appOwnedWarmPaths.rscPaths } : {},
+		...Object.keys(routePatterns).length > 0 ? { routePatterns } : {},
+		...appOwnedWarmPaths.appRoutePaths.length > 0 ? { routeHandlerPaths: appOwnedWarmPaths.appRoutePaths } : {},
+		...includeCanonicalRsc ? { loadingShellPaths: appOwnedWarmPaths.loadingShellPaths } : {},
 		trailingSlash: config.trailingSlash,
-		paths
+		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 ${paths.length} CDN warmup path(s).`);
 	return manifest;
 }
 //#endregion
-export { 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 };