vinext 0.2.1 → 1.0.0-beta.0

package/dist/build/prerender-paths.js

@@ -0,0 +1,296 @@
+import { findDir } from "../utils/project.js";
+import { normalizePathSeparators } from "../utils/path.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 { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
+import { readPrerenderSecret } from "./server-manifest.js";
+import { startProdServer } from "../server/prod-server.js";
+import { buildUrlFromParams, resolveParentParams } from "./prerender.js";
+import fs from "node:fs";
+import path from "node:path";
+//#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;
+function readBuiltBuildId(serverDir) {
+	try {
+		const buildId = fs.readFileSync(path.join(serverDir, "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) {
+	const message = error instanceof Error ? error.message : String(error);
+	console.warn(`[vinext] Warning: failed to discover warmup path(s) for ${route}: ${message}`);
+}
+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 fileHasNamedExport(filePath, name) {
+	if (!filePath) return false;
+	try {
+		return hasNamedExport(fs.readFileSync(filePath, "utf-8"), name);
+	} catch {
+		return false;
+	}
+}
+function resolveConfiguredRouteDirs(root, routeRootConfig) {
+	if (!routeRootConfig) return {
+		appDir: findDir(root, "app", "src/app"),
+		pagesDir: findDir(root, "pages", "src/pages")
+	};
+	let baseDir;
+	if (routeRootConfig.appDir) {
+		baseDir = path.isAbsolute(routeRootConfig.appDir) ? routeRootConfig.appDir : path.resolve(root, routeRootConfig.appDir);
+		baseDir = normalizePathSeparators(baseDir);
+	} else {
+		const hasRootApp = fs.existsSync(path.posix.join(root, "app"));
+		const hasRootPages = fs.existsSync(path.posix.join(root, "pages"));
+		const hasSrcApp = fs.existsSync(path.posix.join(root, "src", "app"));
+		const hasSrcPages = fs.existsSync(path.posix.join(root, "src", "pages"));
+		baseDir = hasRootApp || hasRootPages ? root : hasSrcApp || hasSrcPages ? path.posix.join(root, "src") : root;
+	}
+	const appDir = path.posix.join(baseDir, "app");
+	const pagesDir = path.posix.join(baseDir, "pages");
+	return {
+		appDir: !routeRootConfig.disableAppRouter && fs.existsSync(appDir) ? appDir : null,
+		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 (options.pagesDir) {
+		if ((await pagesRouter(options.pagesDir, options.pageExtensions)).some((route) => route.isDynamic && fileHasNamedExport(route.filePath, "getStaticPaths"))) return true;
+	}
+	return false;
+}
+async function withPrerenderEndpoints(fn) {
+	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
+	const previousPathDiscoveryFlag = process.env[PRERENDER_PATH_DISCOVERY_ENV];
+	process.env.VINEXT_PRERENDER = "1";
+	process.env[PRERENDER_PATH_DISCOVERY_ENV] = "1";
+	try {
+		return await fn();
+	} finally {
+		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
+		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
+		if (previousPathDiscoveryFlag === void 0) delete process.env[PRERENDER_PATH_DISCOVERY_ENV];
+		else process.env[PRERENDER_PATH_DISCOVERY_ENV] = previousPathDiscoveryFlag;
+	}
+}
+async function collectPagesPaths(options) {
+	const [pageRoutes, apiRoutes] = await Promise.all([pagesRouter(options.pagesDir, options.pageExtensions), apiRouter(options.pagesDir, options.pageExtensions)]);
+	const apiPatterns = new Set(apiRoutes.map((route) => route.pattern));
+	const paths = [];
+	const seen = /* @__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;
+		if (!route.isDynamic) {
+			addPath(paths, seen, route.pattern);
+			continue;
+		}
+		if (!fileHasNamedExport(route.filePath, "getStaticPaths")) 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 (text === null) continue;
+			const pathsResult = JSON.parse(text);
+			for (const item of pathsResult.paths ?? []) {
+				const normalized = normalizeStaticPathsEntry(item, route.pattern);
+				if ("error" in normalized) throw new Error(normalized.error);
+				addPath(paths, seen, buildUrlFromParams(route.pattern, normalized.params));
+			}
+		} catch (error) {
+			warnDiscoveryFailure(route.pattern, error);
+		}
+	}
+	return paths;
+}
+async function collectAppPaths(options) {
+	const routes = await appRouter(options.appDir, options.pageExtensions);
+	const paths = [];
+	const seen = /* @__PURE__ */ new Set();
+	const staticParamsCache = /* @__PURE__ */ new Map();
+	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;
+			};
+		},
+		has() {
+			return false;
+		}
+	});
+	for (const route of routes) {
+		const renderEntryPath = getAppRouteRenderEntryPath(route);
+		if (!renderEntryPath) continue;
+		const { type } = classifyAppRoute(renderEntryPath, route.routePath, route.isDynamic);
+		if (type === "api") continue;
+		if (type === "ssr" && !route.isDynamic) continue;
+		if (!route.isDynamic) {
+			addPath(paths, seen, route.pattern);
+			continue;
+		}
+		if (!appRouteMayHaveGenerateStaticParams(route)) continue;
+		try {
+			const generateStaticParams = staticParamsMap[route.pattern];
+			if (typeof generateStaticParams !== "function") continue;
+			const parentParamSets = await resolveParentParams(route, staticParamsMap);
+			let paramSets;
+			if (parentParamSets.length > 0) {
+				paramSets = [];
+				for (const parentParams of parentParamSets) {
+					const childResults = await generateStaticParams({ params: parentParams });
+					if (childResults === null) {
+						paramSets = null;
+						break;
+					}
+					if (Array.isArray(childResults)) for (const childParams of childResults) paramSets.push({
+						...parentParams,
+						...childParams
+					});
+				}
+			} else {
+				const results = await generateStaticParams({ params: {} });
+				paramSets = Array.isArray(results) || results === null ? results : [];
+			}
+			if (!paramSets?.length) continue;
+			for (const params of paramSets) {
+				if (params === null || params === void 0) continue;
+				addPath(paths, seen, buildUrlFromParams(route.pattern, params));
+			}
+		} catch (error) {
+			warnDiscoveryFailure(route.pattern, error);
+		}
+	}
+	return paths;
+}
+async function startPathDiscoveryServer(options) {
+	return startProdServer({
+		port: 0,
+		host: "127.0.0.1",
+		outDir: options.pagesBundlePath ? path.dirname(path.dirname(options.pagesBundlePath)) : path.dirname(options.serverDir),
+		rscEntryPath: options.rscBundlePath,
+		serverEntryPath: options.pagesBundlePath,
+		noCompression: true,
+		purpose: "prerender"
+	});
+}
+async function emitPrerenderPathManifest(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 rscBundlePath = options.rscBundlePath ?? defaultRscBundlePath;
+	const pagesBundlePath = options.pagesBundlePath ?? path.join(root, "dist", "server", "entry.js");
+	const bundleServerDir = fs.existsSync(rscBundlePath) ? path.dirname(rscBundlePath) : path.dirname(pagesBundlePath);
+	const manifestDir = path.join(root, "dist", "server");
+	const loadedConfig = await resolveNextConfig(await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root);
+	const config = options.nextConfigOverride ? {
+		...loadedConfig,
+		...options.nextConfigOverride
+	} : { ...loadedConfig };
+	const builtBuildId = readBuiltBuildId(manifestDir) ?? readBuiltBuildId(bundleServerDir);
+	if (builtBuildId) config.buildId = builtBuildId;
+	const paths = [];
+	const seen = /* @__PURE__ */ new Set();
+	await withPrerenderEndpoints(async () => {
+		let prodServer = null;
+		if (await shouldStartPathDiscoveryServer({
+			appDir,
+			pagesDir,
+			pageExtensions: config.pageExtensions
+		})) try {
+			prodServer = await startPathDiscoveryServer({
+				serverDir: bundleServerDir,
+				pagesBundlePath: !appDir && pagesDir ? pagesBundlePath : void 0,
+				rscBundlePath: appDir ? rscBundlePath : void 0
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.warn(`[vinext] Warning: failed to start prerender path discovery server: ${message}`);
+		}
+		const baseUrl = prodServer ? `http://127.0.0.1:${prodServer.port}` : null;
+		const prerenderSecret = readPrerenderSecret(bundleServerDir) ?? readPrerenderSecret(manifestDir);
+		const secretHeaders = prerenderSecret ? { [VINEXT_PRERENDER_SECRET_HEADER]: prerenderSecret } : {};
+		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);
+		} finally {
+			if (prodServer) await new Promise((resolve) => prodServer.server.close(() => resolve()));
+		}
+	});
+	const manifest = {
+		buildId: config.buildId,
+		trailingSlash: config.trailingSlash,
+		paths
+	};
+	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 };

package/dist/build/prerender.d.ts

@@ -135,6 +135,17 @@ type PrerenderAppOptionsInternal = PrerenderAppOptions & {
  * all '<' and '>' in the embedded JSON, preventing false </script> matches.
  */
 declare function extractRscPayloadFromPrerenderedHtml(html: string): Uint8Array | null;
+/**
+ * Build a URL path from a route pattern and params.
+ * "/posts/:id" + { id: "42" } → "/posts/42"
+ * "/docs/:slug+" + { slug: ["a", "b"] } → "/docs/a/b"
+ *
+ * Throws a descriptive error rather than a cryptic `Cannot read properties of
+ * undefined` if `params` itself is missing or required keys are absent — the
+ * caller (prerenderPages / prerenderApp) catches this and surfaces it as a
+ * per-route error result.
+ */
+declare function buildUrlFromParams(pattern: string, params: Record<string, string | string[]> | undefined | null): string;
 /** Map of route patterns to generateStaticParams functions (or null/undefined). */
 type StaticParamsMap = Record<string, ((opts: {
   params: Record<string, string | string[]>;
@@ -207,4 +218,4 @@ declare function writePrerenderIndex(routes: PrerenderRouteResult[], outDir: str
   trailingSlash?: boolean;
 }): void;
 //#endregion
-export { PrerenderResult, PrerenderRouteResult, StaticParamsMap, extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };
+export { PrerenderResult, PrerenderRouteResult, StaticParamsMap, buildUrlFromParams, extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };

package/dist/build/prerender.js

@@ -1000,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/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.js

@@ -215,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"
@@ -775,6 +779,7 @@ function analyzeConfig(root) {
 		"output",
 		"transpilePackages",
 		"webpack",
+		"cacheComponents",
 		"reactStrictMode",
 		"poweredByHeader",
 		"skipMiddlewareUrlNormalize",

package/dist/cli.js

@@ -8,15 +8,14 @@ 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) => {

package/dist/config/next-config.js

@@ -4,7 +4,6 @@ import { isUnknownRecord } from "../utils/record.js";
 import { getHtmlLimitedBotRegex } from "../utils/html-limited-bots.js";
 import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { loadTsconfigResolutionForRoot } from "./tsconfig-paths.js";
-import { getViteMajorVersion } from "../utils/vite-version.js";
 import { loadCommonJsModule, shouldRetryAsCommonJs } from "../utils/commonjs-loader.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
@@ -315,7 +314,7 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 	const filename = path.basename(configPath);
 	const isTypeScriptConfig = /\.[cm]?ts$/.test(configPath);
 	const tsconfigResolution = loadTsconfigResolutionForRoot(root);
-	const useNativeTsconfigPaths = !!(isTypeScriptConfig ? tsconfigResolution.baseUrl : null) && getViteMajorVersion() >= 8;
+	const useNativeTsconfigPaths = !!(isTypeScriptConfig ? tsconfigResolution.baseUrl : null);
 	const normalizedConfigPath = safeRealpath(path.resolve(configPath));
 	try {
 		const { runnerImport } = await import("vite");

package/dist/config/prerender.d.ts

@@ -1,3 +1,4 @@
+import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VinextCacheConfig, findVinextCacheConfigInPlugins, loadVinextCacheConfigFromViteConfig } from "../cache/cache-adapters-virtual.js";
 import { PluginOption } from "vite";
 
 //#region src/config/prerender.d.ts
@@ -18,12 +19,21 @@ type VinextPrerenderDecision = ResolvedVinextPrerenderConfig & {
   reason: VinextPrerenderDecisionReason;
 };
 declare const VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY = "__vinextPrerenderConfig";
+declare const VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY = "__vinextRouteRootConfig";
+type VinextRouteRootConfig = {
+  appDir?: string;
+  disableAppRouter?: boolean;
+  rscOutDir?: string;
+  ssrOutDir?: string;
+};
 type ViteConfigLoader = {
   loadConfigFromFile: typeof import("vite").loadConfigFromFile;
 };
 declare function normalizeVinextPrerenderConfig(config: VinextPrerenderConfig | undefined): ResolvedVinextPrerenderConfig | null;
 declare function findVinextPrerenderConfigInPlugins(plugins: PluginOption[] | undefined): ResolvedVinextPrerenderConfig | null;
+declare function findVinextRouteRootConfigInPlugins(plugins: PluginOption[] | undefined): VinextRouteRootConfig | null;
 declare function loadVinextPrerenderConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<ResolvedVinextPrerenderConfig | null>;
+declare function loadVinextRouteRootConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<VinextRouteRootConfig | null>;
 declare function resolveVinextPrerenderDecision(options: {
   prerenderAllFlag?: boolean;
   vinextPrerenderConfig?: ResolvedVinextPrerenderConfig | null;
@@ -31,4 +41,4 @@ declare function resolveVinextPrerenderDecision(options: {
 }): VinextPrerenderDecision | null;
 declare function formatVinextPrerenderLabel(decision: VinextPrerenderDecision): string;
 //#endregion
-export { ResolvedVinextPrerenderConfig, VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, VinextPrerenderConfig, VinextPrerenderDecision, VinextPrerenderDecisionReason, findVinextPrerenderConfigInPlugins, formatVinextPrerenderLabel, loadVinextPrerenderConfigFromViteConfig, normalizeVinextPrerenderConfig, resolveVinextPrerenderDecision };
+export { ResolvedVinextPrerenderConfig, VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY, type VinextCacheConfig, VinextPrerenderConfig, VinextPrerenderDecision, VinextPrerenderDecisionReason, VinextRouteRootConfig, findVinextCacheConfigInPlugins, findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, loadVinextCacheConfigFromViteConfig, loadVinextPrerenderConfigFromViteConfig, loadVinextRouteRootConfigFromViteConfig, normalizeVinextPrerenderConfig, resolveVinextPrerenderDecision };