vinext 1.0.0-beta.7 → 1.0.0-beta.9

package/dist/build/prerender-paths.js

@@ -1,21 +1,42 @@
 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 { apiRouter, matchRoute, 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 "../server/headers.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 { appRouteHasMainTreeLoadingBoundary, appRouter, matchAppRoute } from "../routing/app-router.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 { 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 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 +46,153 @@ 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 --experimental-warm-cdn-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 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}\`.`);
+		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 +217,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,56 +243,154 @@ 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 = [];
 	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);
+				if (hasStaticProps || hasServerSideProps) addPath(dataPaths, seenDataPaths, pathname);
+			}
+			else {
+				addPath(paths, seen, route.pattern);
+				if (hasStaticProps || hasServerSideProps) addPath(dataPaths, seenDataPaths, route.pattern);
+			}
 			continue;
 		}
-		if (!fileHasNamedExport(route.filePath, "getStaticPaths")) 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 paths;
+	return {
+		dataPaths,
+		fallbackRoutePatterns,
+		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 resolvePagesWarmRoutePatterns(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, {
+			kind: "pages-page",
+			pattern: match.route.pattern
+		}]] : [];
+	}));
+}
+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}`
+	};
 }
 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 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;
+				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));
+						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 (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");
+				return value;
 			};
 		},
 		has() {
@@ -170,16 +398,30 @@ async function collectAppPaths(options) {
 		}
 	});
 	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 hasMainTreeLoadingBoundary = appRouteHasMainTreeLoadingBoundary(route);
+		const addDiscoveredPath = (pathname) => {
+			if (isRouteHandler) {
+				addPath(routeHandlerPaths, seenRouteHandlerPaths, pathname);
+				return;
+			}
+			addPath(paths, seen, pathname);
+			if (hasMainTreeLoadingBoundary) addPath(loadingShellPaths, seenLoadingShellPaths, pathname);
+		};
 		if (!route.isDynamic) {
-			addPath(paths, seen, route.pattern);
+			addDiscoveredPath(route.pattern);
 			continue;
 		}
-		if (!appRouteMayHaveGenerateStaticParams(route)) continue;
+		requireNonEmptyStaticParams = options.cacheComponents && !isRouteHandler;
 		try {
 			const generateStaticParams = staticParamsMap[route.pattern];
 			if (typeof generateStaticParams !== "function") continue;
@@ -200,18 +442,208 @@ async function collectAppPaths(options) {
 				}
 			} else {
 				const results = await generateStaticParams({ params: {} });
-				paramSets = Array.isArray(results) || results === null ? results : [];
+				if (results === null) {
+					const layoutParamSets = await resolveParentParams(route, staticParamsMap, { includeLastDynamicSegment: true });
+					paramSets = layoutParamSets.length > 0 ? layoutParamSets : null;
+				} else paramSets = 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) 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,
+		loadingShellPaths,
+		paths,
+		routeHandlerPaths
+	};
+}
+async function resolveAppWarmPaths(options) {
+	const appRoutes = await appRouter(options.appDir, options.pageExtensions);
+	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 paths;
+	return {
+		appPaths,
+		appRoutePaths,
+		htmlPaths,
+		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) => {
+		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) {
+	const cachePolicyRules = config.headers.filter((rule) => rule.headers.some((header) => CACHEABILITY_POLICY_HEADER_NAMES.has(header.key.toLowerCase())));
+	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);
+	}
+	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 }
+		}];
+	}));
+}
+function configuredRouteAffectsWarmPath(pathname, 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, {
+		basePath: config.basePath,
+		hadBasePath: true
+	})));
 }
 async function startPathDiscoveryServer(options) {
 	return startProdServer({
@@ -237,16 +669,29 @@ async function emitPrerenderPathManifest(options) {
 	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 discoveredAppPaths = [];
+	const seenAppPaths = /* @__PURE__ */ new Set();
+	const discoveredRouteHandlerPaths = [];
+	const seenRouteHandlerPaths = /* @__PURE__ */ new Set();
+	const discoveredLoadingShellPaths = [];
+	const seenLoadingShellPaths = /* @__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 +699,131 @@ 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,
+					pageExtensions: config.pageExtensions,
+					retryOptions: pathDiscoveryRetryOptions,
+					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.routeHandlerPaths) addPath(discoveredRouteHandlerPaths, seenRouteHandlerPaths, pathname);
+				fallbackRoutePatterns.push(...appPathResult.fallbackRoutePatterns);
+			}
+			if (pagesDir) {
+				const pagesPathResult = await collectPagesPaths({
+					baseUrl,
+					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);
+				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)) : []);
+	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 discoveredPagesDataPathSet = new Set(discoveredPagesDataPaths);
+	const configuredCandidatePaths = paths.filter((pathname) => !excludedWarmPathSet.has(pathname));
+	const configuredRouteHandlerPaths = discoveredRouteHandlerPaths.filter((pathname) => !excludedWarmPathSet.has(pathname));
+	const appOwnedWarmPaths = appDir ? await resolveAppWarmPaths({
+		appDir,
+		i18n: config.i18n,
+		pagesDir,
+		pageExtensions: config.pageExtensions,
+		paths: [...configuredCandidatePaths, ...configuredRouteHandlerPaths]
+	}) : {
+		appPaths: [],
+		appRoutePaths: [],
+		htmlPaths: discoveredAppPaths,
+		loadingShellPaths: discoveredLoadingShellPaths,
+		pagesPaths: resolvedPagesWarmPaths,
+		routePatterns: pagesDir ? await resolvePagesWarmRoutePatterns({
+			i18n: config.i18n,
+			pagesDir,
+			pageExtensions: config.pageExtensions,
+			paths: resolvedPagesWarmPaths
+		}) : {},
+		rscPaths: discoveredAppPaths
+	};
+	const warmPaths = appDir ? appOwnedWarmPaths.htmlPaths : resolvedPagesWarmPaths;
+	const pagesOwnedWarmPaths = appDir ? appOwnedWarmPaths.pagesPaths : resolvedPagesWarmPaths;
+	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);
+	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 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 } : {},
+		...rscBuildId ? { rscBuildId } : {},
+		...options.responseVary ? { responseVary: options.responseVary } : {},
+		...options.responseVary ? { rscPaths: appOwnedWarmPaths.rscPaths } : {},
+		...Object.keys(routePatterns).length > 0 ? { routePatterns } : {},
+		...appOwnedWarmPaths.appRoutePaths.length > 0 ? { routeHandlerPaths: appOwnedWarmPaths.appRoutePaths } : {},
+		...options.responseVary ? { loadingShellPaths: appOwnedWarmPaths.loadingShellPaths } : {},
 		trailingSlash: config.trailingSlash,
-		paths
+		paths: warmPaths
 	};
 	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).`);
+	console.log(`  Discovered ${warmPaths.length + appOwnedWarmPaths.appRoutePaths.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, emitPrerenderPathManifest };