vinext 0.2.0 → 1.0.0-beta.0

package/dist/build/prerender.js

@@ -1,5 +1,6 @@
 import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-matcher.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_PRERENDER_CACHE_LIFE_HEADER } from "../server/headers.js";
 import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from "./report.js";
 import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cache-handler.js";
 import { headersContextFromRequest, runWithHeadersContext } from "../shims/headers.js";
@@ -14,6 +15,7 @@ import { readPrerenderSecret } from "./server-manifest.js";
 import { createAppPprFallbackShells, markAppPprDynamicFallbackShellHtml } from "../server/app-ppr-fallback-shell.js";
 import { getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
 import { startProdServer } from "../server/prod-server.js";
+import { prerenderPoolAvailable, resolvePrerenderPoolSize, startPrerenderServerPool } from "./prerender-server-pool.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -42,6 +44,14 @@ function isExperimentalPprFallbackShellGenerationEnabled(env = process.env) {
 function getErrorMessageWithStack(err) {
 	return err.stack || err.message;
 }
+async function startOptionalPrerenderServerPool(outDir, poolSize) {
+	try {
+		return await startPrerenderServerPool(outDir, poolSize);
+	} catch (e) {
+		console.warn(`[vinext] prerender render pool failed to start; falling back to single-process render: ${e instanceof Error ? e.message : String(e)}`);
+		return null;
+	}
+}
 var PrerenderUserFunctionError = class extends Error {};
 function parsePrerenderEndpointError(text) {
 	try {
@@ -257,11 +267,12 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
 	process.env.VINEXT_PRERENDER = "1";
 	let ownedProdServerHandle = null;
+	let renderPool = null;
 	try {
 		let prerenderSecret = options._prerenderSecret;
 		if (!prerenderSecret && pagesBundlePath) prerenderSecret = readPrerenderSecret(path.dirname(pagesBundlePath));
 		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and dynamic routes will produce no paths. Run `vinext build` to regenerate the secret.");
-		const baseUrl = `http://127.0.0.1:${(options._prodServer ? options._prodServer : await (async () => {
+		const prodServer = options._prodServer ? options._prodServer : await (async () => {
 			const srv = await startProdServer({
 				port: 0,
 				host: "127.0.0.1",
@@ -271,12 +282,18 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 			});
 			ownedProdServerHandle = srv;
 			return srv;
-		})()).port}`;
+		})();
+		const baseUrl = `http://127.0.0.1:${prodServer.port}`;
 		const secretHeaders = prerenderSecret ? { [VINEXT_PRERENDER_SECRET_HEADER]: prerenderSecret } : {};
-		const renderPage = (urlPath) => fetch(`${baseUrl}${urlPath}`, {
-			headers: secretHeaders,
-			redirect: "manual"
-		});
+		let renderPorts = [prodServer.port];
+		let renderRoundRobin = 0;
+		const renderPage = (urlPath) => {
+			const port = renderPorts[renderRoundRobin++ % renderPorts.length];
+			return fetch(`http://127.0.0.1:${port}${urlPath}`, {
+				headers: secretHeaders,
+				redirect: "manual"
+			});
+		};
 		const bundlePageRoutes = routes.map((r) => ({
 			pattern: r.pattern,
 			isDynamic: r.isDynamic ?? false,
@@ -397,6 +414,13 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 				revalidate
 			});
 		}
+		if (!options._prodServer && pagesBundlePath && prerenderPoolAvailable()) {
+			const poolSize = resolvePrerenderPoolSize(pagesToRender.length, concurrency);
+			if (poolSize > 1) {
+				renderPool = await startOptionalPrerenderServerPool(path.dirname(path.dirname(pagesBundlePath)), poolSize);
+				if (renderPool) renderPorts = renderPool.ports;
+			}
+		}
 		let completed = 0;
 		const pageResults = await runWithConcurrency(pagesToRender, concurrency, async ({ route, urlPath, revalidate }) => {
 			let result;
@@ -427,6 +451,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 					...urlPath !== route.pattern ? { path: urlPath } : {}
 				};
 			} catch (e) {
+				renderPool?.recordRenderError(e);
 				const err = e;
 				result = {
 					route: route.pattern,
@@ -443,6 +468,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 			return result;
 		});
 		results.push(...pageResults);
+		renderPool?.assertHealthy();
 		const hasCustom404 = findFileWithExtensions(path.join(pagesDir, "404"), fileMatcher);
 		const hasErrorPage = findFileWithExtensions(path.join(pagesDir, "_error"), fileMatcher);
 		if (hasCustom404 || hasErrorPage) try {
@@ -460,13 +486,17 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 					router: "pages"
 				});
 			}
-		} catch {}
+		} catch (e) {
+			renderPool?.recordRenderError(e);
+		}
+		renderPool?.assertHealthy();
 		if (!skipManifest) writePrerenderIndex(results, manifestDir, {
 			buildId: config.buildId,
 			trailingSlash: config.trailingSlash
 		});
 		return { routes: results };
 	} finally {
+		if (renderPool) await renderPool.close();
 		setCacheHandler(previousHandler);
 		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
 		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
@@ -505,10 +535,13 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 	let rscHandler;
 	let staticParamsMap = {};
 	let ownedProdServerHandle = null;
+	let renderPool = null;
+	let renderPorts = [];
+	let renderRoundRobin = 0;
 	try {
 		const prerenderSecret = readPrerenderSecret(serverDir);
 		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and generateStaticParams will not be called. Run `vinext build` to regenerate the secret.");
-		const baseUrl = `http://127.0.0.1:${(options._prodServer ? options._prodServer : await (async () => {
+		const prodServer = options._prodServer ? options._prodServer : await (async () => {
 			const srv = await startProdServer({
 				port: 0,
 				host: "127.0.0.1",
@@ -518,11 +551,13 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 			});
 			ownedProdServerHandle = srv;
 			return srv;
-		})()).port}`;
+		})();
+		const baseUrl = `http://127.0.0.1:${prodServer.port}`;
+		renderPorts = [prodServer.port];
 		const secretHeaders = prerenderSecret ? { [VINEXT_PRERENDER_SECRET_HEADER]: prerenderSecret } : {};
 		rscHandler = (req) => {
 			const parsed = new URL(req.url);
-			const url = `${baseUrl}${parsed.pathname}${parsed.search}`;
+			const url = `http://127.0.0.1:${renderPorts[renderRoundRobin++ % renderPorts.length]}${parsed.pathname}${parsed.search}`;
 			return fetch(url, {
 				method: req.method,
 				headers: {
@@ -718,12 +753,14 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParams);
 				const htmlHeaders = new Headers();
 				if (prerenderRouteParamsHeader !== null) htmlHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
+				if (isSpeculative) htmlHeaders.set(VINEXT_PRERENDER_SPECULATIVE_HEADER, "1");
 				const htmlRequest = new Request(`http://localhost${urlPath}`, { headers: htmlHeaders });
 				const htmlRender = await runWithHeadersContext(headersContextFromRequest(htmlRequest), async () => {
 					const response = await rscHandler(htmlRequest);
 					const cacheControl = response.headers.get("cache-control") ?? "";
 					const linkHeader = response.headers.get("link");
-					if (!response.ok || isSpeculative && cacheControl.includes("no-store")) {
+					const responseCacheLife = readPrerenderCacheLifeHeader(response.headers);
+					if (!response.ok || cacheControl.includes("no-store")) {
 						await response.body?.cancel();
 						return {
 							cacheControl,
@@ -734,12 +771,14 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 							status: response.status
 						};
 					}
+					const html = await response.text();
+					const processCacheLife = _consumeRequestScopedCacheLife();
 					return {
 						cacheControl,
 						linkHeader,
-						html: await response.text(),
+						html,
 						ok: true,
-						requestCacheLife: _consumeRequestScopedCacheLife(),
+						requestCacheLife: responseCacheLife ?? processCacheLife,
 						status: response.status
 					};
 				});
@@ -756,13 +795,11 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						error: `RSC handler returned ${htmlRender.status}`
 					};
 				}
-				if (isSpeculative) {
-					if (htmlCacheControl.includes("no-store")) return {
-						route: routePattern,
-						status: "skipped",
-						reason: "dynamic"
-					};
-				}
+				if (htmlCacheControl.includes("no-store")) return {
+					route: routePattern,
+					status: "skipped",
+					reason: "dynamic"
+				};
 				if (htmlRender.html === null) return {
 					route: routePattern,
 					status: "error",
@@ -776,6 +813,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						RSC: "1"
 					});
 					if (prerenderRouteParamsHeader !== null) rscHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
+					if (isSpeculative) rscHeaders.set(VINEXT_PRERENDER_SPECULATIVE_HEADER, "1");
 					const rscRequest = new Request(`http://localhost${urlPath}`, { headers: rscHeaders });
 					const rscRes = await runWithHeadersContext(headersContextFromRequest(rscRequest), () => rscHandler(rscRequest));
 					if (!rscRes.ok) {
@@ -809,6 +847,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					...isFallback ? { fallback: true } : {}
 				};
 			} catch (e) {
+				renderPool?.recordRenderError(e);
 				if (isSpeculative) return {
 					route: routePattern,
 					status: "skipped",
@@ -823,6 +862,13 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				};
 			}
 		}
+		if (!options._prodServer && prerenderPoolAvailable()) {
+			const poolSize = resolvePrerenderPoolSize(urlsToRender.length, concurrency);
+			if (poolSize > 1) {
+				renderPool = await startOptionalPrerenderServerPool(path.dirname(serverDir), poolSize);
+				if (renderPool) renderPorts = renderPool.ports;
+			}
+		}
 		let completedApp = 0;
 		const appResults = await runWithConcurrency(urlsToRender, concurrency, async (urlToRender) => {
 			const result = await renderUrl(urlToRender);
@@ -835,6 +881,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 			return result;
 		});
 		results.push(...appResults);
+		renderPool?.assertHealthy();
 		const outputFiles = mode === "export" && metadataRoutes.length > 0 ? emitStaticMetadataFiles(metadataRoutes, outDir) : [];
 		try {
 			const notFoundRequest = new Request(`http://localhost${NOT_FOUND_SENTINEL_PATH}`);
@@ -852,7 +899,10 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					router: "app"
 				});
 			}
-		} catch {}
+		} catch (e) {
+			renderPool?.recordRenderError(e);
+		}
+		renderPool?.assertHealthy();
 		if (!skipManifest) writePrerenderIndex(results, manifestDir, {
 			buildId: config.buildId,
 			trailingSlash: config.trailingSlash
@@ -862,6 +912,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 			...outputFiles.length > 0 ? { outputFiles } : {}
 		};
 	} finally {
+		if (renderPool) await renderPool.close();
 		setCacheHandler(previousHandler);
 		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
 		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
@@ -881,6 +932,19 @@ function resolveRenderedCacheControl(requestCacheLife, cacheControl, fallbackExp
 		...revalidate === void 0 ? {} : { revalidate }
 	};
 }
+function readPrerenderCacheLifeHeader(headers) {
+	const value = headers.get(VINEXT_PRERENDER_CACHE_LIFE_HEADER);
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		const cacheLife = {};
+		if (typeof parsed.revalidate === "number" && Number.isFinite(parsed.revalidate)) cacheLife.revalidate = parsed.revalidate;
+		if (typeof parsed.expire === "number" && Number.isFinite(parsed.expire)) cacheLife.expire = parsed.expire;
+		return cacheLife.revalidate === void 0 && cacheLife.expire === void 0 ? null : cacheLife;
+	} catch {
+		return null;
+	}
+}
 function resolveRenderedExpireSeconds(options) {
 	const { fallbackExpireSeconds, sMaxage, staleWhileRevalidate } = options;
 	if (sMaxage === void 0 || staleWhileRevalidate === void 0) return fallbackExpireSeconds;
@@ -936,4 +1000,4 @@ function writePrerenderIndex(routes, outDir, options) {
 	fs.writeFileSync(path.join(outDir, "vinext-prerender.json"), JSON.stringify(index, null, 2), "utf-8");
 }
 //#endregion
-export { extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };
+export { buildUrlFromParams, extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };

package/dist/build/run-prerender.js

@@ -4,7 +4,7 @@ import { appRouter } from "../routing/app-router.js";
 import { scanMetadataFiles } from "../server/metadata-routes.js";
 import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
 import { readPrerenderSecret } from "./server-manifest.js";
-import { startProdServer } from "../server/prod-server.js";
+import { rememberCurrentServerEntryImportMtime, startProdServer } from "../server/prod-server.js";
 import { prerenderApp, prerenderPages, writePrerenderIndex } from "./prerender.js";
 import { injectPregeneratedConcretePaths } from "./inject-pregenerated-paths.js";
 import fs from "node:fs";
@@ -224,6 +224,7 @@ async function runPrerender(options) {
 		throw new Error(`Static export failed: ${errors} route${errors !== 1 ? "s" : ""} cannot be statically exported.\n${errorRoutes}\n\nRemove server-side data fetching (getServerSideProps, force-dynamic, revalidate) from these routes, or remove \`output: "export"\` from next.config.js.`);
 	}
 	injectPregeneratedConcretePaths(root);
+	if (fs.existsSync(rscBundlePath)) rememberCurrentServerEntryImportMtime(rscBundlePath);
 	return {
 		routes: allRoutes,
 		...allOutputFiles.length > 0 ? { outputFiles: allOutputFiles } : {}

package/dist/cache/cache-adapters-virtual.d.ts

@@ -41,10 +41,16 @@ type VinextCacheConfig = {
 };
 /** Public virtual module id imported by the server entries. */
 declare const VIRTUAL_CACHE_ADAPTERS = "virtual:vinext-cache-adapters";
+declare const VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY = "__vinextCacheConfig";
+type ViteConfigLoader = {
+  loadConfigFromFile: typeof import("vite").loadConfigFromFile;
+};
+declare function findVinextCacheConfigInPlugins(plugins: import("vite").PluginOption[] | undefined): VinextCacheConfig | null;
+declare function loadVinextCacheConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<VinextCacheConfig | null>;
 /**
  * Generate the source of the `virtual:vinext-cache-adapters` module for the
  * given config. Always exports `registerConfiguredCacheAdapters(env)`.
  */
 declare function generateCacheAdaptersModule(cache?: VinextCacheConfig): string;
 //#endregion
-export { VIRTUAL_CACHE_ADAPTERS, VinextCacheConfig, generateCacheAdaptersModule };
+export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, VinextCacheConfig, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, loadVinextCacheConfigFromViteConfig };

package/dist/cache/cache-adapters-virtual.js

@@ -1,6 +1,30 @@
 //#region src/cache/cache-adapters-virtual.ts
 /** Public virtual module id imported by the server entries. */
 const VIRTUAL_CACHE_ADAPTERS = "virtual:vinext-cache-adapters";
+const VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY = "__vinextCacheConfig";
+function flattenPluginOptions(value, target) {
+	if (Array.isArray(value)) {
+		for (const item of value) flattenPluginOptions(item, target);
+		return;
+	}
+	if (value) target.push(value);
+}
+function findVinextCacheConfigInPlugins(plugins) {
+	const flattened = [];
+	flattenPluginOptions(plugins, flattened);
+	for (const plugin of flattened) {
+		if (!plugin || typeof plugin !== "object") continue;
+		const cacheConfig = plugin[VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY];
+		if (cacheConfig) return cacheConfig;
+	}
+	return null;
+}
+async function loadVinextCacheConfigFromViteConfig(vite, root) {
+	return findVinextCacheConfigInPlugins((await vite.loadConfigFromFile({
+		command: "build",
+		mode: "production"
+	}, void 0, root))?.config.plugins);
+}
 /**
 * Serialize descriptor options into a JS expression for inlining. Plain JSON is
 * a valid JS literal; `undefined` when there are no options. Throws a clear
@@ -35,11 +59,11 @@ function generateCacheAdaptersModule(cache) {
 		lines.push(`import __vinextCdnAdapterFactory from ${JSON.stringify(cdn.adapter)};`);
 		lines.push(`import { setCdnCacheAdapter } from "vinext/shims/cdn-cache";`);
 	}
-	lines.push("", "// A factory that throws (e.g. a missing binding on an incompatible runtime)", "// is logged and skipped so the default handler stays in place.", "function __vinextFormatAdapterError(error) {", "  if (error instanceof Error && error.message) return error.message;", "  try {", "    return String(error);", "  } catch {", "    return '<unknown error>';", "  }", "}", "", "let __vinextCacheAdaptersRegistered = false;", "", "export function registerConfiguredCacheAdapters(env) {", "  if (__vinextCacheAdaptersRegistered) return;", "  __vinextCacheAdaptersRegistered = true;");
+	lines.push("", "// A factory that throws (e.g. a missing binding on an incompatible runtime)", "// is logged and skipped so the default handler stays in place.", "function __vinextFormatAdapterError(error) {", "  if (error instanceof Error && error.message) return error.message;", "  try {", "    return String(error);", "  } catch {", "    return '<unknown error>';", "  }", "}", "", "let __vinextCacheAdaptersRegistered = false;", "", "export function registerConfiguredCacheAdapters(env) {", "  if (typeof process !== 'undefined' && process.env?.__VINEXT_PRERENDER_PATH_DISCOVERY === '1') return;", "  if (__vinextCacheAdaptersRegistered) return;", "  __vinextCacheAdaptersRegistered = true;");
 	if (data?.adapter) lines.push("  try {", `    setDataCacheHandler(__vinextDataAdapterFactory({ env, options: ${inlineOptions(data.adapter, data.options)} }));`, "  } catch (error) {", "    console.warn(\"[vinext] failed to initialize the configured data cache adapter; using the default handler.\\n\" + __vinextFormatAdapterError(error));", "  }");
 	if (cdn?.adapter) lines.push("  try {", `    setCdnCacheAdapter(__vinextCdnAdapterFactory({ env, options: ${inlineOptions(cdn.adapter, cdn.options)} }));`, "  } catch (error) {", "    console.warn(\"[vinext] failed to initialize the configured CDN cache adapter; using the default adapter.\\n\" + __vinextFormatAdapterError(error));", "  }");
 	lines.push("}", "");
 	return lines.join("\n");
 }
 //#endregion
-export { VIRTUAL_CACHE_ADAPTERS, generateCacheAdaptersModule };
+export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, loadVinextCacheConfigFromViteConfig };

package/dist/check.d.ts

@@ -60,9 +60,8 @@ declare function hasFreeCjsGlobal(content: string): boolean;
 /**
  * Scan source files for `import ... from 'next/...'` statements.
  *
- * `root` must be forward-slash: it is passed to `findSourceFiles` (which
- * requires it) and used as the base of `path.posix.relative`, which only yields
- * a canonical relative path when both operands are forward-slash.
+ * `root` must be forward-slash: it is passed to `findSourceFiles`, which
+ * requires it.
  */
 declare function scanImports(root: string): CheckItem[];
 /**
@@ -82,9 +81,8 @@ declare function checkLibraries(root: string): CheckItem[];
 /**
  * Check file conventions (pages, app directory, middleware, etc.)
  *
- * `root` must be forward-slash — joined with `path.posix.join`, passed to
- * `findDir`, and used as the base of `path.posix.relative`. Only called from
- * `runCheck`, which normalizes it.
+ * `root` must be forward-slash — joined with `path.posix.join` and passed to
+ * `findDir`. Only called from `runCheck`, which normalizes it.
  */
 declare function checkConventions(root: string): CheckItem[];
 /**

package/dist/check.js

@@ -1,4 +1,5 @@
 import { detectPackageManager, findDir } from "./utils/project.js";
+import { normalizePathSeparators } from "./utils/path.js";
 import fs from "node:fs";
 import path from "node:path";
 import { parseAst } from "vite";
@@ -214,6 +215,10 @@ const CONFIG_SUPPORT = {
 		status: "supported",
 		detail: "sourcemap-resolved stack traces during prerender"
 	},
+	cacheComponents: {
+		status: "partial",
+		detail: "experimental support; behavior is incomplete"
+	},
 	"experimental.ppr": {
 		status: "unsupported",
 		detail: "partial prerendering not yet implemented"
@@ -300,7 +305,7 @@ const CONFIG_SUPPORT = {
 	},
 	reactStrictMode: {
 		status: "partial",
-		detail: "config option recognized but not yet enforced; root is not wrapped in <React.StrictMode>"
+		detail: "enforced for the Pages Router (client root wrapped in <React.StrictMode> when true); App Router is not yet wrapped (Next.js defaults App Router strict mode on)"
 	},
 	poweredByHeader: {
 		status: "supported",
@@ -588,9 +593,8 @@ function hasFreeCjsGlobal(content) {
 /**
 * Scan source files for `import ... from 'next/...'` statements.
 *
-* `root` must be forward-slash: it is passed to `findSourceFiles` (which
-* requires it) and used as the base of `path.posix.relative`, which only yields
-* a canonical relative path when both operands are forward-slash.
+* `root` must be forward-slash: it is passed to `findSourceFiles`, which
+* requires it.
 */
 function scanImports(root) {
 	const files = findSourceFiles(root);
@@ -608,7 +612,7 @@ function scanImports(root) {
 			if (mod.startsWith("next/") || mod === "next" || mod === "server-only" || mod === "client-only") {
 				const normalized = mod === "next" ? "next" : mod;
 				if (!importUsage.has(normalized)) importUsage.set(normalized, []);
-				const relFile = path.posix.relative(root, file);
+				const relFile = normalizePathSeparators(path.relative(root, file));
 				const usedInFiles = importUsage.get(normalized) ?? [];
 				if (!usedInFiles.includes(relFile)) usedInFiles.push(relFile);
 			}
@@ -775,6 +779,7 @@ function analyzeConfig(root) {
 		"output",
 		"transpilePackages",
 		"webpack",
+		"cacheComponents",
 		"reactStrictMode",
 		"poweredByHeader",
 		"skipMiddlewareUrlNormalize",
@@ -830,9 +835,8 @@ function checkLibraries(root) {
 /**
 * Check file conventions (pages, app directory, middleware, etc.)
 *
-* `root` must be forward-slash — joined with `path.posix.join`, passed to
-* `findDir`, and used as the base of `path.posix.relative`. Only called from
-* `runCheck`, which normalizes it.
+* `root` must be forward-slash — joined with `path.posix.join` and passed to
+* `findDir`. Only called from `runCheck`, which normalizes it.
 */
 function checkConventions(root) {
 	const items = [];
@@ -931,7 +935,7 @@ function checkConventions(root) {
 	const cjsGlobalFiles = [];
 	for (const file of allSourceFiles) {
 		const content = fs.readFileSync(file, "utf-8");
-		const rel = path.posix.relative(root, file);
+		const rel = normalizePathSeparators(path.relative(root, file));
 		if (viewTransitionRegex.test(content)) viewTransitionFiles.push(rel);
 		if (hasFreeCjsGlobal(content)) cjsGlobalFiles.push(rel);
 	}

package/dist/cli.js

@@ -1,22 +1,21 @@
 #!/usr/bin/env node
 import { detectPackageManager, ensureViteConfigCompatibility, hasAppDir, hasViteConfig } from "./utils/project.js";
+import { normalizePathSeparators } from "./utils/path.js";
 import { formatReport, runCheck } from "./check.js";
 import { parseArgs } from "./cli-args.js";
 import { createDevServerConfigPlugin, normalizeDevServerHostname } from "./cli-dev-config.js";
-import { normalizePathSeparators } from "./utils/path.js";
 import { PHASE_PRODUCTION_BUILD } from "./shims/constants.js";
 import { createRscCompatibilityId, loadNextConfig, resolveNextConfig } from "./config/next-config.js";
 import { generateRouteTypes } from "./typegen.js";
 import { clearPagesClientAssetsBuildMetadata } from "./build/pages-client-assets-module.js";
-import { findVinextPrerenderConfigInPlugins, formatVinextPrerenderLabel, resolveVinextPrerenderDecision } from "./config/prerender.js";
+import { findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, resolveVinextPrerenderDecision } from "./config/prerender.js";
 import vinext from "./index.js";
 import { runPrerender } from "./build/run-prerender.js";
-import { loadDotenv } from "./config/dotenv.js";
-import { deploy, parseDeployArgs } from "./packages/cloudflare/src/deploy.js";
-import { printDeployHelp } from "./packages/cloudflare/src/deploy-help.js";
+import { emitPrerenderPathManifest } from "./build/prerender-paths.js";
 import { getReactUpgradeDeps } from "./utils/react-version.js";
 import { init } from "./init.js";
-import { INIT_PLATFORMS, resolveInitPlatform, resolveInitPrerender } from "./init-platform.js";
+import { resolveInitOptions } from "./init-platform.js";
+import { loadDotenv } from "./config/dotenv.js";
 import { resolveVinextPackageRoot } from "./utils/vinext-root.js";
 import { emitStandaloneOutput } from "./build/standalone.js";
 import { cleanBuildOutput } from "./build/clean-output.js";
@@ -34,7 +33,6 @@ import { execFileSync } from "node:child_process";
 *   vinext dev     Start development server (Vite)
 *   vinext build   Build for production
 *   vinext start   Start production server
-*   vinext deploy  Deprecated Cloudflare deploy shim
 *   vinext typegen Generate App Router route helper types
 *   vinext lint    Run linter (delegates to eslint/oxlint)
 *
@@ -128,7 +126,10 @@ function hasPagesDir() {
 	return fs.existsSync(path.join(process.cwd(), "pages")) || fs.existsSync(path.join(process.cwd(), "src", "pages"));
 }
 async function loadBuildViteConfigMetadata(vite, root) {
-	if (!hasViteConfig(root)) return { prerenderConfig: null };
+	if (!hasViteConfig(root)) return {
+		prerenderConfig: null,
+		routeRootConfig: null
+	};
 	const loaded = await vite.loadConfigFromFile({
 		command: "build",
 		mode: "production"
@@ -136,7 +137,8 @@ async function loadBuildViteConfigMetadata(vite, root) {
 	const emptyOutDir = loaded?.config.build?.emptyOutDir;
 	return {
 		emptyOutDir: typeof emptyOutDir === "boolean" ? emptyOutDir : void 0,
-		prerenderConfig: findVinextPrerenderConfigInPlugins(loaded?.config.plugins)
+		prerenderConfig: findVinextPrerenderConfigInPlugins(loaded?.config.plugins),
+		routeRootConfig: findVinextRouteRootConfigInPlugins(loaded?.config.plugins)
 	};
 }
 /**
@@ -277,8 +279,7 @@ async function buildApp() {
 	});
 	applyViteConfigCompatibility(process.cwd());
 	const vite = await loadVite();
-	const viteMajorVersion = Number.parseInt(vite.version, 10) || 7;
-	const withBuildBundlerOptions = (bundlerOptions) => viteMajorVersion >= 8 ? { rolldownOptions: bundlerOptions } : { rollupOptions: bundlerOptions };
+	const withBuildBundlerOptions = (bundlerOptions) => ({ rolldownOptions: bundlerOptions });
 	console.log(`\n  vinext build  (Vite ${getViteVersion()})\n`);
 	const root = process.cwd();
 	const isApp = hasAppDir(normalizePathSeparators(root));
@@ -330,7 +331,7 @@ async function buildApp() {
 					mode: "production",
 					isSsrBuild: true
 				}, void 0, root);
-				if (loaded?.config.plugins) userTransformPlugins = loaded.config.plugins.flat(Infinity).filter((p) => !!p && typeof p.name === "string" && !p.name.startsWith("vinext:") && !p.name.startsWith("vite:react") && !p.name.startsWith("rsc:") && p.name !== "vite-rsc-load-module-dev-proxy" && p.name !== "vite-tsconfig-paths" && !p.name.startsWith("vite-plugin-cloudflare"));
+				if (loaded?.config.plugins) userTransformPlugins = loaded.config.plugins.flat(Infinity).filter((p) => !!p && typeof p.name === "string" && !p.name.startsWith("vinext:") && !p.name.startsWith("vite:react") && !p.name.startsWith("rsc:") && p.name !== "vite-rsc-load-module-dev-proxy" && !p.name.startsWith("vite-plugin-cloudflare"));
 			}
 			await vite.build({
 				root,
@@ -383,6 +384,11 @@ async function buildApp() {
 			root: normalizePathSeparators(process.cwd()),
 			concurrency: parsed.prerenderConcurrency
 		});
+		await emitPrerenderPathManifest({
+			root: normalizePathSeparators(process.cwd()),
+			nextConfigOverride: resolvedNextConfig,
+			routeRootConfig: buildConfigMetadata.routeRootConfig
+		});
 	}
 	process.stdout.write("\x1B[0m");
 	const { printBuildReport } = await import("./build/report.js");
@@ -452,33 +458,9 @@ async function lint() {
 		process.exit(1);
 	}
 }
-async function deployCommand() {
-	const parsed = parseDeployArgs(rawArgs);
-	if (parsed.help) {
-		printDeployDeprecationWarning();
-		printDeployHelp();
-		return;
-	}
-	printDeployDeprecationWarning();
-	await loadVite();
-	console.log(`\n  vinext deploy  (Vite ${getViteVersion()})\n`);
-	await deploy({
-		root: process.cwd(),
-		preview: parsed.preview,
-		env: parsed.env,
-		skipBuild: parsed.skipBuild,
-		dryRun: parsed.dryRun,
-		name: parsed.name,
-		prerenderAll: parsed.prerenderAll,
-		prerenderConcurrency: parsed.prerenderConcurrency,
-		experimentalTPR: parsed.experimentalTPR,
-		tprCoverage: parsed.tprCoverage,
-		tprLimit: parsed.tprLimit,
-		tprWindow: parsed.tprWindow
-	});
-}
-function printDeployDeprecationWarning() {
-	console.log("  ⚠️  Warning: `vinext deploy` has moved to the `@vinext/cloudflare` package.\n  Please switch to `npx @vinext/cloudflare deploy` or `vp exec vinext-cloudflare deploy`; this compatibility command will be removed in a future release.\n");
+function failRemovedDeployCommand() {
+	console.error("\n  Error: `vinext deploy` has moved to the `@vinext/cloudflare` package.\n\n  Run `npx @vinext/cloudflare deploy` or `vp exec vinext-cloudflare deploy` instead.\n");
+	process.exit(1);
 }
 async function check() {
 	if (parseArgs(rawArgs).help) return printHelp("check");
@@ -508,17 +490,13 @@ async function initCommand() {
 	const port = parsed.port ?? 3001;
 	const skipCheck = rawArgs.includes("--skip-check");
 	const force = rawArgs.includes("--force");
-	const platform = await resolveInitPlatform(rawArgs);
-	const platformOptions = await INIT_PLATFORMS[platform].options(rawArgs);
-	const prerender = await resolveInitPrerender(rawArgs);
+	const initOptions = await resolveInitOptions(rawArgs);
 	await init({
 		root: process.cwd(),
 		port,
 		skipCheck,
 		force,
-		platform,
-		prerender,
-		cloudflare: platform === "cloudflare" ? platformOptions : void 0
+		...initOptions
 	});
 }
 function printHelp(cmd) {
@@ -574,11 +552,7 @@ function printHelp(cmd) {
 `);
 		return;
 	}
-	if (cmd === "deploy") {
-		printDeployDeprecationWarning();
-		printDeployHelp();
-		return;
-	}
+	if (cmd === "deploy") failRemovedDeployCommand();
 	if (cmd === "check") {
 		console.log(`
   vinext check - Scan Next.js app for compatibility
@@ -611,6 +585,11 @@ function printHelp(cmd) {
     --platform <target>  Deployment target: cloudflare or node
     --prerender          Configure vinext build to pre-render all static routes
                          (default: prompt, with No selected by default)
+    --experimental-warm-cdn-cache
+                         Add experimental CDN pre-warming to the Cloudflare deploy script
+                         (Workers Cache CDN only, default: prompt with No)
+    --cdn-cache <type>   Cloudflare CDN cache: workers-cache or data-cache
+                         (default: workers-cache)
     --data-cache <type>  Cloudflare data cache: kv or none (default: kv)
     --image-optimization <type>
                          Cloudflare image optimization: cloudflare-images or none
@@ -619,11 +598,15 @@ function printHelp(cmd) {
   Examples:
     vinext init                   Prompt for a deployment platform
     vinext init --platform=cloudflare  Configure Cloudflare Workers (default)
+    vinext init --platform=cloudflare --cdn-cache=data-cache
+                                Fall through CDN caching to the data cache
     vinext init --platform=cloudflare --data-cache=kv
                                 Configure the default Cloudflare cache handlers
     vinext init --platform=cloudflare --image-optimization=none
                                 Do not configure Cloudflare Images
     vinext init --prerender     Add prerender: { routes: "*" } to vite.config.ts
+    vinext init --experimental-warm-cdn-cache
+                                Add experimental CDN pre-warming to deploy:vinext
     vinext init --platform=node   Configure a Node deployment
     vinext init -p 4000           Use port 4000 for dev:vinext
     vinext init --force           Overwrite existing vite.config.ts
@@ -722,10 +705,7 @@ switch (command) {
 		});
 		break;
 	case "deploy":
-		deployCommand().catch((e) => {
-			console.error(e);
-			process.exit(1);
-		});
+		failRemovedDeployCommand();
 		break;
 	case "init":
 		initCommand().catch((e) => {