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

package/dist/build/prerender.d.ts

@@ -181,7 +181,9 @@ type StaticParamsMap = Record<string, ((opts: {
  * Uses the `staticParamsMap` (pattern → generateStaticParams) exported from
  * the production bundle.
  */
-declare function resolveParentParams(childRoute: AppRoute, staticParamsMap: StaticParamsMap): Promise<Record<string, string | string[]>[]>;
+declare function resolveParentParams(childRoute: AppRoute, staticParamsMap: StaticParamsMap, options?: {
+  includeLastDynamicSegment?: boolean;
+}): Promise<Record<string, string | string[]>[]>;
 /**
  * Run the prerender phase for Pages Router.
  *
@@ -202,7 +204,7 @@ declare function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, m
  * Starts a local production server and fetches every static/ISR route via HTTP.
  * Works for both plain Node and Cloudflare Workers builds — the CF Workers bundle
  * (`dist/server/index.js`) is a standard Node-compatible server entry, so no
- * wrangler/miniflare is needed. Writes HTML files, `.rsc` files, and
+ * wrangler/miniflare is needed. Writes HTML files, Flight payloads, and
  * `vinext-prerender.json` to `outDir`.
  *
  * If the bundle does not exist, an error is thrown directing the user to run

package/dist/build/prerender.js

@@ -181,16 +181,28 @@ function metadataOutputPath(servedUrl) {
 	if (segments.length === 0 || segments.some((segment) => segment === "." || segment === "..")) return null;
 	return segments.join("/");
 }
-function emitStaticMetadataFiles(metadataRoutes, outDir) {
+function emitStaticMetadataFiles(metadataRoutes, outDir, basePath = "") {
 	const outputFiles = [];
+	const outputPrefix = basePath.replace(/^\//, "").replace(/\/$/, "");
 	for (const route of metadataRoutes) {
 		if (route.isDynamic) continue;
 		const outputPath = metadataOutputPath(route.servedUrl);
 		if (!outputPath) continue;
-		const fullPath = path.join(outDir, ...outputPath.split("/"));
+		const namespacedOutputPath = outputPrefix ? `${outputPrefix}/${outputPath}` : outputPath;
+		const fullPath = path.join(outDir, ...namespacedOutputPath.split("/"));
 		fs.mkdirSync(path.dirname(fullPath), { recursive: true });
 		fs.copyFileSync(route.filePath, fullPath);
-		outputFiles.push(outputPath);
+		outputFiles.push(namespacedOutputPath);
+	}
+	return outputFiles;
+}
+function emitStatic404Files(outDir, html, trailingSlash) {
+	const outputFiles = ["404.html"];
+	if (trailingSlash) outputFiles.push("404/index.html");
+	for (const outputFile of outputFiles) {
+		const fullPath = path.join(outDir, ...outputFile.split("/"));
+		fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+		fs.writeFileSync(fullPath, html, "utf-8");
 	}
 	return outputFiles;
 }
@@ -201,7 +213,7 @@ function emitStaticMetadataFiles(metadataRoutes, outDir) {
 * Uses the `staticParamsMap` (pattern → generateStaticParams) exported from
 * the production bundle.
 */
-async function resolveParentParams(childRoute, staticParamsMap) {
+async function resolveParentParams(childRoute, staticParamsMap, options = {}) {
 	const { patternParts } = childRoute;
 	let lastDynamicIdx = -1;
 	for (let i = patternParts.length - 1; i >= 0; i--) if (patternParts[i].startsWith(":")) {
@@ -210,7 +222,8 @@ async function resolveParentParams(childRoute, staticParamsMap) {
 	}
 	const parentSegments = [];
 	let prefixPattern = "";
-	for (let i = 0; i < lastDynamicIdx; i++) {
+	const prefixEnd = options.includeLastDynamicSegment ? lastDynamicIdx + 1 : lastDynamicIdx;
+	for (let i = 0; i < prefixEnd; i++) {
 		const part = patternParts[i];
 		prefixPattern += "/" + part;
 		if (!part.startsWith(":")) continue;
@@ -292,7 +305,9 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 		let renderRoundRobin = 0;
 		const renderPage = (urlPath) => {
 			const port = renderPorts[renderRoundRobin++ % renderPorts.length];
-			return fetch(`http://127.0.0.1:${port}${urlPath}`, {
+			const routeRequestPath = config.trailingSlash && !urlPath.endsWith("/") ? `${urlPath}/` : urlPath;
+			const requestPath = config.basePath && routeRequestPath === "/" && !config.trailingSlash ? config.basePath : `${config.basePath ?? ""}${routeRequestPath}`;
+			return fetch(`http://127.0.0.1:${port}${requestPath}`, {
 				headers: secretHeaders,
 				redirect: "manual"
 			});
@@ -316,7 +331,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 						fallback: false
 					};
 				}
-				if (text === "null") return {
+				if (res.status === 204 || text === "null") return {
 					paths: [],
 					fallback: false
 				};
@@ -430,7 +445,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 			try {
 				const response = await renderPage(urlPath);
 				const outputFiles = [];
-				const htmlOutputPath = getOutputPath(urlPath, config.trailingSlash);
+				const htmlOutputPath = getOutputPath(urlPath, config.trailingSlash, mode === "export" ? config.basePath : "");
 				const htmlFullPath = path.join(outDir, htmlOutputPath);
 				if (response.status >= 300 && response.status < 400) {
 					const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0;url=${(response.headers.get("location") ?? "/").replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}" /></head><body></body></html>`;
@@ -479,12 +494,10 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 			const contentType = notFoundRes.headers.get("content-type") ?? "";
 			if (notFoundRes.status === 404 && contentType.includes("text/html")) {
 				const html404 = await notFoundRes.text();
-				const fullPath = path.join(outDir, "404.html");
-				fs.writeFileSync(fullPath, html404, "utf-8");
 				results.push({
 					route: "/404",
 					status: "rendered",
-					outputFiles: ["404.html"],
+					outputFiles: emitStatic404Files(outDir, html404, config.trailingSlash),
 					revalidate: false,
 					router: "pages"
 				});
@@ -514,7 +527,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 * Starts a local production server and fetches every static/ISR route via HTTP.
 * Works for both plain Node and Cloudflare Workers builds — the CF Workers bundle
 * (`dist/server/index.js`) is a standard Node-compatible server entry, so no
-* wrangler/miniflare is needed. Writes HTML files, `.rsc` files, and
+* wrangler/miniflare is needed. Writes HTML files, Flight payloads, and
 * `vinext-prerender.json` to `outDir`.
 *
 * If the bundle does not exist, an error is thrown directing the user to run
@@ -589,7 +602,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 							console.warn(`[vinext] Warning: /__vinext/prerender/static-params returned ${res.status} for ${pattern}. Static params will be skipped. This may indicate a stale or missing prerender secret.`);
 							return null;
 						}
-						if (text === "null") return null;
+						if (res.status === 204 || text === "null") return null;
 						return JSON.parse(text);
 					})();
 					request.catch(() => staticParamsCache.delete(cacheKey));
@@ -829,7 +842,9 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				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 routeRequestPath = config.trailingSlash && !urlPath.endsWith("/") ? `${urlPath}/` : urlPath;
+				const requestPath = config.basePath && routeRequestPath === "/" && !config.trailingSlash ? config.basePath : `${config.basePath ?? ""}${routeRequestPath}`;
+				const htmlRequest = new Request(`http://localhost${requestPath}`, { headers: htmlHeaders });
 				const htmlRender = await runWithHeadersContext(headersContextFromRequest(htmlRequest), async () => {
 					const response = await rscHandler(htmlRequest);
 					const cacheControl = response.headers.get("cache-control") ?? "";
@@ -896,7 +911,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					});
 					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 rscRequest = new Request(`http://localhost${requestPath}`, { headers: rscHeaders });
 					const rscRes = await runWithHeadersContext(headersContextFromRequest(rscRequest), () => rscHandler(rscRequest));
 					if (!rscRes.ok) {
 						await rscRes.body?.cancel();
@@ -905,12 +920,16 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					rscData = new Uint8Array(await rscRes.arrayBuffer());
 				}
 				const outputFiles = [];
-				const htmlOutputPath = getOutputPath(urlPath, config.trailingSlash);
+				const htmlOutputPath = getOutputPath(urlPath, config.trailingSlash, mode === "export" ? config.basePath : "");
 				const htmlFullPath = path.join(outDir, htmlOutputPath);
 				fs.mkdirSync(path.dirname(htmlFullPath), { recursive: true });
 				fs.writeFileSync(htmlFullPath, html, "utf-8");
 				outputFiles.push(htmlOutputPath);
-				const rscOutputPath = getRscOutputPath(urlPath);
+				const rscOutputPath = getRscOutputPath(urlPath, {
+					mode,
+					trailingSlash: config.trailingSlash,
+					basePath: mode === "export" ? config.basePath : ""
+				});
 				const rscFullPath = path.join(outDir, rscOutputPath);
 				fs.mkdirSync(path.dirname(rscFullPath), { recursive: true });
 				fs.writeFileSync(rscFullPath, rscData);
@@ -967,19 +986,17 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 		});
 		results.push(...appResults);
 		renderPool?.assertHealthy();
-		const outputFiles = mode === "export" && metadataRoutes.length > 0 ? emitStaticMetadataFiles(metadataRoutes, outDir) : [];
+		const outputFiles = mode === "export" && metadataRoutes.length > 0 ? emitStaticMetadataFiles(metadataRoutes, outDir, config.basePath) : [];
 		try {
-			const notFoundRequest = new Request(`http://localhost${NOT_FOUND_SENTINEL_PATH}`);
+			const notFoundPath = config.trailingSlash && !NOT_FOUND_SENTINEL_PATH.endsWith("/") ? `${NOT_FOUND_SENTINEL_PATH}/` : NOT_FOUND_SENTINEL_PATH;
+			const notFoundRequest = new Request(`http://localhost${config.basePath ?? ""}${notFoundPath}`);
 			const notFoundRes = await runWithHeadersContext(headersContextFromRequest(notFoundRequest), () => rscHandler(notFoundRequest));
 			if (notFoundRes.status === 404) {
 				const html404 = await notFoundRes.text();
-				const fullPath = path.join(outDir, "404.html");
-				fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-				fs.writeFileSync(fullPath, html404, "utf-8");
 				results.push({
 					route: "/404",
 					status: "rendered",
-					outputFiles: ["404.html"],
+					outputFiles: emitStatic404Files(outDir, html404, config.trailingSlash),
 					revalidate: false,
 					router: "app"
 				});

package/dist/build/report.d.ts

@@ -92,6 +92,8 @@ declare function classifyLayoutSegmentConfig(code: string): LayoutBuildClassific
  * API routes (files under pages/api/) are always `api`.
  */
 declare function classifyPagesRoute(filePath: string): {
+  hasStaticProps?: boolean;
+  hasServerSideProps?: boolean;
   type: RouteType;
   revalidate?: number;
 };
@@ -106,6 +108,19 @@ declare function classifyAppRoute(pagePath: string | null, routePath: string | n
   type: RouteType;
   revalidate?: number;
 };
+/**
+ * Return whether a Route Handler has a GET contract that Next.js considers
+ * eligible for static generation. This intentionally examines only the route
+ * module's direct segment config; request-time dynamic usage is decided by the
+ * staged Worker probe after the module has executed to completion.
+ *
+ * Ported from Next.js:
+ * packages/next/src/server/route-modules/app-route/helpers/is-static-gen-enabled.ts
+ */
+declare function classifyAppRouteHandler(filePath: string): {
+  hasGet: boolean;
+  staticGenerationEnabled: boolean;
+};
 /**
  * Builds a sorted list of RouteRow objects from the discovered routes.
  * Routes are sorted alphabetically by path, matching filesystem order.
@@ -144,4 +159,4 @@ declare function printBuildReport(options: {
   prerenderResult?: PrerenderResult;
 }): Promise<void>;
 //#endregion
-export { RouteRow, RouteType, StaticMiddlewareMatcher, buildReportRows, classifyAppRoute, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, extractMiddlewareMatcherConfig, extractMiddlewareMatcherConfigValue, formatBuildReport, getAppRouteRenderEntryPath, hasExportedName, hasNamedExport, printBuildReport };
+export { RouteRow, RouteType, StaticMiddlewareMatcher, buildReportRows, classifyAppRoute, classifyAppRouteHandler, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, extractMiddlewareMatcherConfig, extractMiddlewareMatcherConfigValue, formatBuildReport, getAppRouteRenderEntryPath, hasExportedName, hasNamedExport, printBuildReport };

package/dist/build/report.js

@@ -97,6 +97,20 @@ function hasNamedExportInProgram(program, name) {
 	}
 	return false;
 }
+function hasRuntimeExportedNameInProgram(program, name) {
+	for (const node of program.body) {
+		if (node.type !== "ExportNamedDeclaration" || node.exportKind === "type") continue;
+		if (declarationHasBindingName(node.declaration, name)) return true;
+		for (const specifier of node.specifiers) {
+			if (specifier.exportKind === "type") continue;
+			if (moduleExportNameValue(specifier.exported ?? specifier.local) === name) return true;
+		}
+	}
+	return false;
+}
+function hasRuntimeExportAllInProgram(program) {
+	return program.body.some((node) => node.type === "ExportAllDeclaration" && node.exportKind !== "type");
+}
 function unwrapStaticExpression(expression) {
 	let current = expression;
 	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") current = current.expression;
@@ -434,12 +448,19 @@ function classifyPagesRoute(filePath) {
 		return { type: "unknown" };
 	}
 	const program = parseRouteModule(code);
-	if (program && hasNamedExportInProgram(program, "getServerSideProps")) return { type: "ssr" };
+	if (program && hasNamedExportInProgram(program, "getServerSideProps")) return {
+		hasServerSideProps: true,
+		type: "ssr"
+	};
 	if (program && hasNamedExportInProgram(program, "getStaticProps")) {
 		const revalidate = extractGetStaticPropsRevalidateFromProgram(program, code);
-		if (revalidate === null || revalidate === false || revalidate === Infinity) return { type: "static" };
+		if (revalidate === null || revalidate === false || revalidate === Infinity) return {
+			hasStaticProps: true,
+			type: "static"
+		};
 		if (revalidate === 0) return { type: "ssr" };
 		return {
+			hasStaticProps: true,
 			type: "isr",
 			revalidate
 		};
@@ -480,6 +501,46 @@ function classifyAppRoute(pagePath, routePath, isDynamic) {
 	return { type: "unknown" };
 }
 /**
+* Return whether a Route Handler has a GET contract that Next.js considers
+* eligible for static generation. This intentionally examines only the route
+* module's direct segment config; request-time dynamic usage is decided by the
+* staged Worker probe after the module has executed to completion.
+*
+* Ported from Next.js:
+* packages/next/src/server/route-modules/app-route/helpers/is-static-gen-enabled.ts
+*/
+function classifyAppRouteHandler(filePath) {
+	let code;
+	try {
+		code = fs.readFileSync(filePath, "utf8");
+	} catch {
+		return {
+			hasGet: false,
+			staticGenerationEnabled: false
+		};
+	}
+	const program = parseRouteModule(code);
+	if (!program) return {
+		hasGet: false,
+		staticGenerationEnabled: false
+	};
+	const dynamicValue = extractExportConstStringFromProgram(program, "dynamic");
+	const revalidateValue = extractExportConstNumberFromProgram(program, "revalidate");
+	const hasGet = hasRuntimeExportedNameInProgram(program, "GET");
+	const hasNonStaticMethod = [
+		"POST",
+		"PUT",
+		"DELETE",
+		"PATCH",
+		"OPTIONS"
+	].some((method) => hasRuntimeExportedNameInProgram(program, method));
+	const hasUnknownRuntimeExports = hasRuntimeExportAllInProgram(program);
+	return {
+		hasGet,
+		staticGenerationEnabled: !hasNonStaticMethod && !hasUnknownRuntimeExports && (dynamicValue === "force-static" || dynamicValue === "error" || revalidateValue === Infinity || revalidateValue !== null && revalidateValue > 0 || hasRuntimeExportedNameInProgram(program, "generateStaticParams"))
+	};
+}
+/**
 * Builds a sorted list of RouteRow objects from the discovered routes.
 * Routes are sorted alphabetically by path, matching filesystem order.
 *
@@ -606,4 +667,4 @@ async function printBuildReport(options) {
 	}
 }
 //#endregion
-export { buildReportRows, classifyAppRoute, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, extractMiddlewareMatcherConfig, extractMiddlewareMatcherConfigValue, formatBuildReport, getAppRouteRenderEntryPath, hasExportedName, hasNamedExport, printBuildReport };
+export { buildReportRows, classifyAppRoute, classifyAppRouteHandler, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, extractMiddlewareMatcherConfig, extractMiddlewareMatcherConfigValue, formatBuildReport, getAppRouteRenderEntryPath, hasExportedName, hasNamedExport, printBuildReport };

package/dist/build/static-export.d.ts

@@ -20,7 +20,7 @@ type StaticExportOptions = {
   config: ResolvedNextConfig;
 };
 type StaticExportResult = {
-  /** Number of HTML files generated */
+  /** Number of rendered route entries */
   pageCount: number;
   /** Generated file paths (relative to outDir) */
   files: string[];

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

@@ -6,6 +6,45 @@
  * by hand. `options` must be JSON-serializable: it is inlined into the generated
  * registration module and forwarded to the adapter factory at runtime.
  */
+type CdnCacheAdapterCapabilities = {
+  /**
+   * Page responses include the current application build identity in the
+   * framework-owned `X-Vinext-Build-Id` response header, including responses
+   * that are ultimately marked non-cacheable.
+   *
+   * Deploy adapters use this guarantee to distinguish the newly uploaded
+   * Worker from an older version while staged traffic is propagating.
+   */
+  buildIdentity?: "response-header";
+  /**
+   * The shared cache selects response variants using every request header
+   * named by `Vary`, comparing the header values verbatim.
+   *
+   * Vinext only uses the canonical deploy-warmed RSC request shape when this
+   * guarantee is present. URL-only caches retain the contextual `_rsc` digest.
+   */
+  responseVary?: "verbatim";
+  /**
+   * Cacheable App Page responses require a build-bound probe manifest before
+   * the adapter may emit public CDN cache policy. Cloudflare deploy tooling
+   * carries that manifest as a module in a second Worker version.
+   */
+  routeCacheability?: "probe-manifest";
+};
+type CacheAdapterBuildOutput = {
+  /** Whether this adapter owns output for the resolved build platform. */
+  matchesBuild?: (build: {
+    plugins: readonly {
+      name?: string;
+    }[];
+  }) => boolean;
+  /** Finalize an emitted directory after other platform output hooks. */
+  finalizeBuildOutput?: (output: {
+    root: string;
+    outDir: string;
+    isPrimaryServerOutput: boolean;
+  }) => Promise<void> | void;
+};
 type CacheAdapterDescriptor<O extends Record<string, unknown> = Record<string, unknown>> = {
   /**
    * Module specifier (or absolute path, e.g. from `require.resolve(...)`) whose
@@ -14,7 +53,14 @@ type CacheAdapterDescriptor<O extends Record<string, unknown> = Record<string, u
   adapter: string;
   /** JSON-serializable options forwarded to the factory at runtime. */
   options?: O;
+  /** Optional adapter-owned finalization for platform-generated build output. */
+  output?: CacheAdapterBuildOutput;
+  /** Build-time cache semantics used by shared request protocol code. */
+  capabilities?: CdnCacheAdapterCapabilities;
 };
+declare function hasVerbatimResponseVary(cache?: VinextCacheConfig | null): boolean;
+declare function hasBuildIdentityResponseHeader(cache?: VinextCacheConfig | null): boolean;
+declare function requiresRouteCacheabilityProbeManifest(cache?: VinextCacheConfig | null): boolean;
 /**
  * The `cache` option of the vinext() plugin: declaratively register cache
  * handlers instead of calling `setDataCacheHandler()` / `setCdnCacheAdapter()`
@@ -40,4 +86,4 @@ declare function loadVinextCacheConfigFromViteConfig(vite: ViteConfigLoader, roo
  */
 declare function generateCacheAdaptersModule(cache?: VinextCacheConfig): string;
 //#endregion
-export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, VinextCacheConfig, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, loadVinextCacheConfigFromViteConfig };
+export { CacheAdapterBuildOutput, CacheAdapterDescriptor, CdnCacheAdapterCapabilities, VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, VinextCacheConfig, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, hasBuildIdentityResponseHeader, hasVerbatimResponseVary, loadVinextCacheConfigFromViteConfig, requiresRouteCacheabilityProbeManifest };

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

@@ -16,6 +16,15 @@ import { flattenPluginOptions } from "../utils/plugin-options.js";
 * never touches the Workers runtime — instantiation is deferred to the first
 * request.
 */
+function hasVerbatimResponseVary(cache) {
+	return cache?.cdn?.capabilities?.responseVary === "verbatim";
+}
+function hasBuildIdentityResponseHeader(cache) {
+	return cache?.cdn?.capabilities?.buildIdentity === "response-header";
+}
+function requiresRouteCacheabilityProbeManifest(cache) {
+	return cache?.cdn?.capabilities?.routeCacheability === "probe-manifest";
+}
 /** Public virtual module id imported by the server entries. */
 const VIRTUAL_CACHE_ADAPTERS = "virtual:vinext-cache-adapters";
 const VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY = "__vinextCacheConfig";
@@ -75,4 +84,4 @@ function generateCacheAdaptersModule(cache) {
 	return lines.join("\n");
 }
 //#endregion
-export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, loadVinextCacheConfigFromViteConfig };
+export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, hasBuildIdentityResponseHeader, hasVerbatimResponseVary, loadVinextCacheConfigFromViteConfig, requiresRouteCacheabilityProbeManifest };

package/dist/cli.js

@@ -4,6 +4,7 @@ import { detectPackageManager, ensureViteConfigCompatibility, hasAppDir, hasVite
 import { formatReport, runCheck } from "./check.js";
 import { parseArgs } from "./cli-args.js";
 import { createDevServerConfigPlugin, normalizeDevServerHostname } from "./cli-dev-config.js";
+import { findVinextCacheConfigInPlugins, hasBuildIdentityResponseHeader, hasVerbatimResponseVary } from "./cache/cache-adapters-virtual.js";
 import { PHASE_PRODUCTION_BUILD } from "./shims/constants.js";
 import { createRscCompatibilityId, findVinextNextConfigInPlugins, loadNextConfig, resolveNextConfig, resolveNextConfigInput } from "./config/next-config.js";
 import { loadDotenv } from "./config/dotenv.js";
@@ -127,6 +128,7 @@ function hasPagesDir() {
 }
 async function loadBuildViteConfigMetadata(vite, root, mode) {
 	if (!hasViteConfig(root)) return {
+		cacheConfig: null,
 		nextConfig: null,
 		prerenderConfig: null,
 		routeRootConfig: null
@@ -137,6 +139,7 @@ async function loadBuildViteConfigMetadata(vite, root, mode) {
 	}, void 0, root);
 	const emptyOutDir = loaded?.config.build?.emptyOutDir;
 	return {
+		cacheConfig: await findVinextCacheConfigInPlugins(loaded?.config.plugins),
 		emptyOutDir: typeof emptyOutDir === "boolean" ? emptyOutDir : void 0,
 		nextConfig: await findVinextNextConfigInPlugins(loaded?.config.plugins),
 		prerenderConfig: await findVinextPrerenderConfigInPlugins(loaded?.config.plugins),
@@ -293,7 +296,9 @@ async function buildApp() {
 	const resolvedNextConfig = await resolveNextConfig(buildConfigMetadata.nextConfig ? await resolveNextConfigInput(buildConfigMetadata.nextConfig, PHASE_PRODUCTION_BUILD) : await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root);
 	process.env.__VINEXT_SHARED_BUILD_ID = resolvedNextConfig.buildId;
 	process.env.__VINEXT_SHARED_RSC_COMPATIBILITY_ID = createRscCompatibilityId(resolvedNextConfig);
+	process.env.__VINEXT_SHARED_RSC_BUILD_IDENTITY = randomBytes(16).toString("hex");
 	if (!process.env.__VINEXT_SHARED_REVALIDATE_SECRET) process.env.__VINEXT_SHARED_REVALIDATE_SECRET = randomBytes(32).toString("hex");
+	if (!process.env.__VINEXT_SHARED_PRERENDER_SECRET) process.env.__VINEXT_SHARED_PRERENDER_SECRET = randomBytes(32).toString("hex");
 	const outputMode = resolvedNextConfig.output;
 	const distDir = path.resolve(root, "dist");
 	if (outputMode === "standalone") {
@@ -397,6 +402,8 @@ async function buildApp() {
 		await emitPrerenderPathManifest({
 			root,
 			nextConfig: resolvedNextConfig,
+			buildIdentity: hasBuildIdentityResponseHeader(buildConfigMetadata.cacheConfig) ? "response-header" : void 0,
+			responseVary: hasVerbatimResponseVary(buildConfigMetadata.cacheConfig) ? "verbatim" : void 0,
 			routeRootConfig: buildConfigMetadata.routeRootConfig
 		});
 	}

package/dist/client/vinext-next-data.d.ts

@@ -2,6 +2,8 @@ import { NEXT_DATA } from "../shims/internal/utils.js";
 //#region src/client/vinext-next-data.d.ts
 type VinextLinkPrefetchRoute = {
   canPrefetchLoadingShell: boolean;
+  /** The loading shell is an ordinary main-tree variant shared with deploy warmup. */
+  canUseCanonicalLoadingShell?: true;
   documentOnly?: boolean;
   isDynamic: boolean;
   patternParts: string[];

package/dist/config/config-matchers.d.ts

@@ -110,7 +110,7 @@ declare function matchConfigPattern(pathname: string, pattern: string): Record<s
  * an original index < N are checked via matchConfigPattern first — they are
  * few in practice (typically zero) so this is not a hot-path concern.
  */
-declare function matchRedirect(pathname: string, redirects: NextRedirect[], ctx: RequestContext, basePathState?: BasePathMatchState): {
+declare function matchRedirect(pathname: string, redirects: NextRedirect[], ctx: RequestContext, basePathState?: BasePathMatchState, onRuleSourceMatch?: (rule: NextRedirect) => void): {
   destination: string;
   permanent: boolean;
 } | null;
@@ -122,7 +122,7 @@ declare function matchRedirect(pathname: string, redirects: NextRedirect[], ctx:
  * to evaluate has/missing conditions. Next.js always has request context
  * when evaluating rewrites, so this parameter is required.
  */
-declare function matchRewrite(pathname: string, rewrites: NextRewrite[], ctx: RequestContext, basePathState?: BasePathMatchState, paramsPathname?: string): string | null;
+declare function matchRewrite(pathname: string, rewrites: NextRewrite[], ctx: RequestContext, basePathState?: BasePathMatchState, paramsPathname?: string, onRuleSourceMatch?: (rule: NextRewrite) => void): string | null;
 /**
  * Check whether a rewrite source can match a pathname without evaluating its
  * request-dependent `has` / `missing` conditions.
@@ -187,7 +187,7 @@ declare function proxyExternalRequest(request: Request, externalUrl: string): Pr
  * to evaluate has/missing conditions. Next.js always has request context
  * when evaluating headers, so this parameter is required.
  */
-declare function matchHeaders(pathname: string, headers: NextHeader[], ctx: RequestContext, basePathState?: BasePathMatchState): Array<{
+declare function matchHeaders(pathname: string, headers: NextHeader[], ctx: RequestContext, basePathState?: BasePathMatchState, onRuleSourceMatch?: (rule: NextHeader) => void): Array<{
   key: string;
   value: string;
 }>;

package/dist/config/config-matchers.js

@@ -546,7 +546,7 @@ function matchConfigPattern(pathname, pattern) {
 * an original index < N are checked via matchConfigPattern first — they are
 * few in practice (typically zero) so this is not a hot-path concern.
 */
-function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAULT) {
+function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAULT, onRuleSourceMatch) {
 	if (redirects.length === 0) return null;
 	const normalizedPathname = stripTrailingSlashForConfigMatch(pathname);
 	const index = _getRedirectIndex(redirects);
@@ -559,6 +559,7 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 			if (entry.originalIndex >= localeMatchIndex) continue;
 			const redirect = entry.redirect;
 			if (!shouldEvaluateRule(redirect.basePath, basePathState)) continue;
+			onRuleSourceMatch?.(redirect);
 			const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
 			localeMatch = {
@@ -581,6 +582,7 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 				if (!entry.altRe.test(localePart)) continue;
 				const redirect = entry.redirect;
 				if (!shouldEvaluateRule(redirect.basePath, basePathState)) continue;
+				onRuleSourceMatch?.(redirect);
 				const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 				if (!conditionParams) continue;
 				localeMatch = {
@@ -600,6 +602,7 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 		if (!shouldEvaluateRule(redirect.basePath, basePathState)) continue;
 		const params = matchConfigPattern(pathname, redirect.source);
 		if (params) {
+			onRuleSourceMatch?.(redirect);
 			const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
 			return {
@@ -621,11 +624,12 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 * to evaluate has/missing conditions. Next.js always has request context
 * when evaluating rewrites, so this parameter is required.
 */
-function matchRewrite(pathname, rewrites, ctx, basePathState = _BASEPATH_DEFAULT, paramsPathname = pathname) {
+function matchRewrite(pathname, rewrites, ctx, basePathState = _BASEPATH_DEFAULT, paramsPathname = pathname, onRuleSourceMatch) {
 	for (const rewrite of rewrites) {
 		if (!shouldEvaluateRule(rewrite.basePath, basePathState)) continue;
 		const matchedParams = matchConfigPattern(pathname, rewrite.source);
 		if (matchedParams) {
+			onRuleSourceMatch?.(rewrite);
 			const params = paramsPathname === pathname ? matchedParams : matchConfigPattern(paramsPathname, rewrite.source) ?? matchedParams;
 			const conditionParams = rewrite.has || rewrite.missing ? collectConditionParams(rewrite.has, rewrite.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
@@ -891,7 +895,7 @@ async function proxyExternalRequest(request, externalUrl) {
 * to evaluate has/missing conditions. Next.js always has request context
 * when evaluating headers, so this parameter is required.
 */
-function matchHeaders(pathname, headers, ctx, basePathState = _BASEPATH_DEFAULT) {
+function matchHeaders(pathname, headers, ctx, basePathState = _BASEPATH_DEFAULT, onRuleSourceMatch) {
 	const pathnameHadTrailingSlash = pathname.length > 1 && pathname.endsWith("/");
 	pathname = stripTrailingSlashForConfigMatch(pathname);
 	const result = [];
@@ -900,6 +904,7 @@ function matchHeaders(pathname, headers, ctx, basePathState = _BASEPATH_DEFAULT)
 		const source = pathnameHadTrailingSlash ? stripTrailingSlashForConfigMatch(rule.source) : rule.source;
 		const sourceRegex = getCachedRegex(_compiledHeaderSourceCache, source, () => safeRegExp("^" + escapeHeaderSource(source) + "$", "i"));
 		if (sourceRegex && sourceRegex.test(pathname)) {
+			onRuleSourceMatch?.(rule);
 			if (rule.has || rule.missing) {
 				if (!checkHasConditions(rule.has, rule.missing, ctx)) continue;
 			}

package/dist/config/prerender.d.ts

@@ -1,4 +1,4 @@
-import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VinextCacheConfig, findVinextCacheConfigInPlugins, loadVinextCacheConfigFromViteConfig } from "../cache/cache-adapters-virtual.js";
+import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VinextCacheConfig, findVinextCacheConfigInPlugins, hasBuildIdentityResponseHeader, hasVerbatimResponseVary, loadVinextCacheConfigFromViteConfig, requiresRouteCacheabilityProbeManifest } from "../cache/cache-adapters-virtual.js";
 import { PluginOption } from "vite";
 //#region src/config/prerender.d.ts
 type VinextPrerenderConfig = true | {
@@ -40,4 +40,4 @@ declare function resolveVinextPrerenderDecision(options: {
 }): VinextPrerenderDecision | null;
 declare function formatVinextPrerenderLabel(decision: VinextPrerenderDecision): string;
 //#endregion
-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 };
+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, hasBuildIdentityResponseHeader, hasVerbatimResponseVary, loadVinextCacheConfigFromViteConfig, loadVinextPrerenderConfigFromViteConfig, loadVinextRouteRootConfigFromViteConfig, normalizeVinextPrerenderConfig, requiresRouteCacheabilityProbeManifest, resolveVinextPrerenderDecision };

package/dist/config/prerender.js

@@ -1,6 +1,6 @@
 import { isUnknownRecord } from "../utils/record.js";
 import { flattenPluginOptions } from "../utils/plugin-options.js";
-import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, findVinextCacheConfigInPlugins, loadVinextCacheConfigFromViteConfig } from "../cache/cache-adapters-virtual.js";
+import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, findVinextCacheConfigInPlugins, hasBuildIdentityResponseHeader, hasVerbatimResponseVary, loadVinextCacheConfigFromViteConfig, requiresRouteCacheabilityProbeManifest } from "../cache/cache-adapters-virtual.js";
 //#region src/config/prerender.ts
 const VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY = "__vinextPrerenderConfig";
 const VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY = "__vinextRouteRootConfig";
@@ -62,4 +62,4 @@ function formatVinextPrerenderLabel(decision) {
 	return "Pre-rendering all routes...";
 }
 //#endregion
-export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY, findVinextCacheConfigInPlugins, findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, loadVinextCacheConfigFromViteConfig, loadVinextPrerenderConfigFromViteConfig, loadVinextRouteRootConfigFromViteConfig, normalizeVinextPrerenderConfig, resolveVinextPrerenderDecision };
+export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY, findVinextCacheConfigInPlugins, findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, hasBuildIdentityResponseHeader, hasVerbatimResponseVary, loadVinextCacheConfigFromViteConfig, loadVinextPrerenderConfigFromViteConfig, loadVinextRouteRootConfigFromViteConfig, normalizeVinextPrerenderConfig, requiresRouteCacheabilityProbeManifest, resolveVinextPrerenderDecision };

package/dist/entries/app-browser-entry.d.ts

@@ -13,7 +13,7 @@ declare function generateBrowserEntry(routes?: readonly AppRoute[], routeManifes
   afterFiles: NextRewrite[];
   beforeFiles: NextRewrite[];
   fallback: NextRewrite[];
-}): string;
+}, locales?: readonly string[]): string;
 /** Project an `AppRoute` down to the public `VinextLinkPrefetchRoute` shape. */
 declare function toLinkPrefetchRoute(route: AppRoute, hasSiblingInterceptLoading?: boolean): VinextLinkPrefetchRoute;
 /** Project App routes together so sibling-intercept loading is applied to its target route. */

package/dist/entries/app-browser-entry.js

@@ -1,6 +1,7 @@
 import { resolveClientRuntimeModule, resolveRuntimeEntryModule } from "./runtime-entry-module.js";
 import { toClientRewrites } from "../client/client-rewrites.js";
 import { patternsStructurallyEquivalent } from "../routing/app-route-graph.js";
+import { appRouteHasMainTreeLoadingBoundary } from "../routing/app-router.js";
 //#region src/entries/app-browser-entry.ts
 /**
 * Generate the virtual browser entry module.
@@ -13,7 +14,7 @@ function generateBrowserEntry(routes = [], routeManifest = null, pagesPrefetchRo
 	afterFiles: [],
 	beforeFiles: [],
 	fallback: []
-}) {
+}, locales = []) {
 	const entryPath = resolveRuntimeEntryModule("app-browser-entry");
 	const reactInstanceBootstrapPath = resolveClientRuntimeModule("react-instance-bootstrap");
 	const navigationRuntimePath = resolveClientRuntimeModule("navigation-runtime");
@@ -29,6 +30,7 @@ window.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(prefetchRoutes)};
 // the same — whichever entry runs first emits both globals).
 window.__VINEXT_PAGES_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(pagesPrefetchRoutes)};
 window.__VINEXT_CLIENT_REWRITES__ = ${JSON.stringify(clientRewrites)};
+window.__VINEXT_LOCALES__ = ${JSON.stringify(locales)};
 registerNavigationRuntimeBootstrap({
     routeManifest: ${buildRouteManifestExpression(routeManifest)}
 });
@@ -68,6 +70,7 @@ function hasLoadingBoundary(route, hasSiblingInterceptLoading) {
 function toLinkPrefetchRoute(route, hasSiblingInterceptLoading = route.siblingIntercepts.some((intercept) => interceptTargetsRoute(intercept.targetPattern, route) && (intercept.loadingPaths?.length ?? 0) > 0)) {
 	return {
 		canPrefetchLoadingShell: hasLoadingBoundary(route, hasSiblingInterceptLoading),
+		...appRouteHasMainTreeLoadingBoundary(route) ? { canUseCanonicalLoadingShell: true } : {},
 		patternParts: [...route.patternParts],
 		isDynamic: route.isDynamic,
 		...requiresDynamicNavigationRequest(route) ? { requiresDynamicNavigationRequest: true } : {},