vinext 1.0.0-beta.10 → 1.0.0-beta.12

package/README.md

@@ -4,9 +4,7 @@ Run Next.js applications on Vite, with Cloudflare Workers as the primary deploym
 
 **Website:** [vinext.dev](https://vinext.dev)
 
-**Documentation:**
-
-- [Caching](docs/caching.md)
+**Documentation:** [vinext.dev/docs](https://vinext.dev/docs)
 
 > **Read the announcement:** [How we rebuilt Next.js with AI in one week](https://blog.cloudflare.com/vinext/)
 
@@ -122,7 +120,7 @@ Your existing `pages/`, `app/`, `next.config.js`, and `public/` directories work
 
 Options: `-p / --port <port>`, `-H / --hostname <host>`, `--turbopack` (accepted, no-op).
 
-`@vinext/cloudflare deploy` options: `--preview`, `--env <name>`, `--name <name>`, `--skip-build`, `--dry-run`, `--experimental-tpr`.
+`@vinext/cloudflare deploy` options: `--preview`, `--env <name>`, `--name <name>`, `--skip-build`, `--dry-run`, `--experimental-traffic-aware-warm-cache`.
 
 `vinext init` prompts for a deployment target, defaulting to Cloudflare. Agents must ask the
 user which target they want, then pass `--platform=cloudflare` or `--platform=node`.
@@ -335,20 +333,22 @@ For TypeScript types, generate them with `wrangler types` and the `env` import w
 
 > **Note:** You do not need `getPlatformProxy()`, a custom worker entry with `fetch(request, env)`, or any other workaround. `cloudflare:workers` is the recommended way to access bindings in vinext.
 
-#### Traffic-aware Pre-Rendering (experimental)
+#### Traffic-aware pre-warming (experimental)
 
-TPR queries Cloudflare zone analytics at deploy time to find which pages actually get traffic, pre-renders only those, and uploads them to KV cache. The result is SSG-level latency for popular pages without pre-rendering your entire site.
+Traffic-aware warming queries Cloudflare zone analytics at deploy time to select the routes that actually get traffic. Those routes then go through vinext's standard staged CDN pre-warming flow, including route resolution, cacheability checks, and promotion.
 
 ```bash
-npx @vinext/cloudflare deploy --experimental-tpr                    # Pre-render pages covering 90% of traffic
-vp exec vinext-cloudflare deploy --experimental-tpr                 # Same, with Vite+
-npx @vinext/cloudflare deploy --experimental-tpr --tpr-coverage 95  # More aggressive coverage
-npx @vinext/cloudflare deploy --experimental-tpr --tpr-limit 500    # Cap at 500 pages
-npx @vinext/cloudflare deploy --experimental-tpr --tpr-window 48    # Use 48h of analytics
+npx @vinext/cloudflare deploy --experimental-traffic-aware-warm-cache                              # Pre-warm routes covering 90% of traffic
+vp exec vinext-cloudflare deploy --experimental-traffic-aware-warm-cache                           # Same, with Vite+
+npx @vinext/cloudflare deploy --experimental-traffic-aware-warm-cache --traffic-aware-coverage 95  # More aggressive coverage
+npx @vinext/cloudflare deploy --experimental-traffic-aware-warm-cache --traffic-aware-limit 500    # Cap at 500 routes
+npx @vinext/cloudflare deploy --experimental-traffic-aware-warm-cache --traffic-aware-window 48    # Use 48h of analytics
 ```
 
 Requires a custom domain (zone analytics are unavailable on `*.workers.dev`) and `CLOUDFLARE_API_TOKEN` with Zone.Analytics read permission.
 
+The previous `--experimental-tpr` and `--tpr-*` names remain supported as aliases.
+
 #### Custom Vite configuration
 
 If you need to customize the Vite config, create a `vite.config.ts`. vinext will merge its config with yours. For Cloudflare Workers deployment with the App Router, configure `@cloudflare/vite-plugin` so the RSC environment runs in workerd:
@@ -598,7 +598,7 @@ Every `next/*` import is shimmed to a Vite-compatible implementation.
 | Standalone output (`output: 'standalone'`) | ✅  | Generates `dist/standalone` with `server.js`, build artifacts, and runtime deps             |
 | `connection()`                             | ✅  | Forces dynamic rendering                                                                    |
 | `"use cache"` directive                    | ✅  | File-level and function-level. `cacheLife()` profiles, `cacheTag()`, stale-while-revalidate |
-| `instrumentation.ts`                       | ✅  | `register()` and `onRequestError()` callbacks                                               |
+| `instrumentation.ts`                       | ✅  | `register()`, `onRequestError()`, and [framework tracing](docs/tracing.mdx)                 |
 | Route segment config                       | 🟡  | `revalidate`, `dynamic`, `dynamicParams`. `runtime` and `preferredRegion` are ignored       |
 
 ### Configuration

package/THIRD_PARTY_LICENSES.md

@@ -0,0 +1,25 @@
+# Third-party licenses
+
+## ua-parser-js
+
+MIT License
+
+Copyright (c) 2012-2021 Faisal Salman <f@faisalman.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,25 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+export { __commonJSMin, __toESM };

package/dist/build/prerender-paths.d.ts

@@ -53,6 +53,10 @@ export declare const DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS = 1000;
 export declare const DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS = 120000;
 type PrerenderPathDiscoveryOptions = {
   root: string;
+  /** Additional concrete public paths to resolve through the route graph. */
+  candidatePaths?: readonly string[];
+  /** Resolve only candidate paths instead of enumerating dynamic route hooks. */
+  candidatePathsOnly?: boolean;
   /** Fully resolved Next.js config. Loaded from disk when omitted. */
   nextConfig?: ResolvedNextConfig;
   appDir?: string | null;

package/dist/build/prerender-paths.js

@@ -270,6 +270,7 @@ async function collectPagesPaths(options) {
 			}
 			continue;
 		}
+		if (!options.enumerateDynamicPaths) continue;
 		if (type === "ssr") continue;
 		if (!options.baseUrl) continue;
 		try {
@@ -319,16 +320,31 @@ async function excludePagesApiWarmPaths(options) {
 		return matchRoute(pagesPathname, apiRoutes) === null;
 	});
 }
-async function resolvePagesWarmRoutePatterns(options) {
+async function resolvePagesWarmRouteMetadata(options) {
 	const pageRoutes = await pagesRouter(options.pagesDir, options.pageExtensions);
-	return Object.fromEntries(options.paths.flatMap((pathname) => {
+	const classifications = /* @__PURE__ */ new Map();
+	const dataPaths = [];
+	const routePatterns = {};
+	for (const pathname of options.paths) {
 		const pagesPathname = options.i18n ? extractLocaleFromUrl(pathname, options.i18n).url : pathname;
 		const match = matchRoute(pagesPathname, pageRoutes);
-		return match ? [[pathname, {
+		if (!match) continue;
+		routePatterns[pathname] = {
 			kind: "pages-page",
 			pattern: match.route.pattern
-		}]] : [];
-	}));
+		};
+		let classification = classifications.get(match.route.filePath);
+		if (!classification) {
+			classification = classifyPagesRoute(match.route.filePath);
+			classifications.set(match.route.filePath, classification);
+		}
+		const { hasServerSideProps, hasStaticProps } = classification;
+		if (hasServerSideProps || hasStaticProps) dataPaths.push(pathname);
+	}
+	return {
+		dataPaths,
+		routePatterns
+	};
 }
 function localizePagesPath(pathname, locale, i18n) {
 	if (!i18n || !locale || locale === i18n.defaultLocale) return pathname;
@@ -364,8 +380,6 @@ async function collectAppPaths(options) {
 	const routes = await appRouter(options.appDir, options.pageExtensions);
 	const paths = [];
 	const seen = /* @__PURE__ */ new Set();
-	const loadingShellPaths = [];
-	const seenLoadingShellPaths = /* @__PURE__ */ new Set();
 	const routeHandlerPaths = [];
 	const seenRouteHandlerPaths = /* @__PURE__ */ new Set();
 	const fallbackRoutePatterns = [];
@@ -418,20 +432,19 @@ async function collectAppPaths(options) {
 			const { type } = classifyAppRoute(renderEntryPath, route.routePath, route.isDynamic);
 			if (type === "api") continue;
 		}
-		const hasMainTreeLoadingBoundary = appRouteHasMainTreeLoadingBoundary(route);
 		const addDiscoveredPath = (pathname) => {
 			if (isRouteHandler) {
 				addPath(routeHandlerPaths, seenRouteHandlerPaths, pathname);
 				return;
 			}
 			addPath(paths, seen, pathname);
-			if (hasMainTreeLoadingBoundary) addPath(loadingShellPaths, seenLoadingShellPaths, pathname);
 		};
 		if (!route.isDynamic) {
 			addDiscoveredPath(route.pattern);
 			addPath(nonDynamicPaths, seenNonDynamicPaths, route.pattern);
 			continue;
 		}
+		if (!options.enumerateDynamicPaths) continue;
 		requireNonEmptyStaticParams = options.cacheComponents && !isRouteHandler;
 		try {
 			const generateStaticParams = staticParamsMap[route.pattern];
@@ -502,7 +515,6 @@ async function collectAppPaths(options) {
 	}
 	return {
 		fallbackRoutePatterns,
-		loadingShellPaths,
 		nonDynamicPaths,
 		paths,
 		routeHandlerPaths
@@ -725,12 +737,8 @@ async function discoverPrerenderPathManifest(options) {
 	const seenPagesPaths = /* @__PURE__ */ new Set();
 	const discoveredPagesDataPaths = [];
 	const seenPagesDataPaths = /* @__PURE__ */ new Set();
-	const discoveredAppPaths = [];
-	const seenAppPaths = /* @__PURE__ */ new Set();
 	const discoveredRouteHandlerPaths = [];
 	const seenRouteHandlerPaths = /* @__PURE__ */ new Set();
-	const discoveredLoadingShellPaths = [];
-	const seenLoadingShellPaths = /* @__PURE__ */ new Set();
 	const discoveredNonDynamicPathSet = /* @__PURE__ */ new Set();
 	const fallbackRoutePatterns = [];
 	await withPrerenderEndpoints(async () => {
@@ -767,15 +775,12 @@ async function discoverPrerenderPathManifest(options) {
 					appDir,
 					baseUrl,
 					cacheComponents: config.cacheComponents,
+					enumerateDynamicPaths: options.candidatePathsOnly !== true,
 					pageExtensions: config.pageExtensions,
 					retryOptions: pathDiscoveryRetryOptions,
 					secretHeaders
 				});
-				for (const pathname of appPathResult.paths) {
-					addPath(paths, seen, pathname);
-					addPath(discoveredAppPaths, seenAppPaths, pathname);
-				}
-				for (const pathname of appPathResult.loadingShellPaths) addPath(discoveredLoadingShellPaths, seenLoadingShellPaths, pathname);
+				for (const pathname of appPathResult.paths) addPath(paths, seen, pathname);
 				for (const pathname of appPathResult.routeHandlerPaths) addPath(discoveredRouteHandlerPaths, seenRouteHandlerPaths, pathname);
 				for (const pathname of appPathResult.nonDynamicPaths) discoveredNonDynamicPathSet.add(pathname);
 				fallbackRoutePatterns.push(...appPathResult.fallbackRoutePatterns);
@@ -783,6 +788,7 @@ async function discoverPrerenderPathManifest(options) {
 			if (pagesDir) {
 				const pagesPathResult = await collectPagesPaths({
 					baseUrl,
+					enumerateDynamicPaths: options.candidatePathsOnly !== true,
 					i18n: config.i18n,
 					pagesDir,
 					pageExtensions: config.pageExtensions,
@@ -801,6 +807,16 @@ async function discoverPrerenderPathManifest(options) {
 			if (prodServer) await new Promise((resolve) => prodServer.server.close(() => resolve()));
 		}
 	});
+	for (const publicPathname of options.candidatePaths ?? []) {
+		let pathname = normalizePathTrailingSlash(new URL(publicPathname, "http://vinext.local").pathname, false);
+		if (config.basePath) {
+			if (pathname === config.basePath) pathname = "/";
+			else if (pathname.startsWith(`${config.basePath}/`)) pathname = pathname.slice(config.basePath.length);
+			else continue;
+		}
+		addPath(paths, seen, pathname);
+		if (pagesDir) addPath(discoveredPagesPaths, seenPagesPaths, pathname);
+	}
 	const hasStagedRequestRouting = options.requestRouting === "uncached-stage";
 	const middlewarePath = hasStagedRequestRouting ? findMiddlewareConventionFile(root, appDir, pagesDir, config.pageExtensions) : null;
 	const configuredMatcher = middlewarePath ? extractMiddlewareMatcherConfig(middlewarePath) : void 0;
@@ -816,9 +832,20 @@ async function discoverPrerenderPathManifest(options) {
 		pageExtensions: config.pageExtensions,
 		paths: configuredPagesWarmPaths
 	}) : configuredPagesWarmPaths;
-	const discoveredPagesDataPathSet = new Set(discoveredPagesDataPaths);
 	const configuredCandidatePaths = paths.filter((pathname) => !excludedWarmPathSet.has(pathname));
 	const configuredRouteHandlerPaths = discoveredRouteHandlerPaths.filter((pathname) => !excludedWarmPathSet.has(pathname));
+	const pagesWarmMetadata = pagesDir ? await resolvePagesWarmRouteMetadata({
+		i18n: config.i18n,
+		pagesDir,
+		pageExtensions: config.pageExtensions,
+		paths: resolvedPagesWarmPaths
+	}) : {
+		dataPaths: [],
+		routePatterns: {}
+	};
+	for (const pathname of pagesWarmMetadata.dataPaths) addPath(discoveredPagesDataPaths, seenPagesDataPaths, pathname);
+	const discoveredPagesDataPathSet = new Set(discoveredPagesDataPaths);
+	const pagesOnlyWarmPaths = resolvedPagesWarmPaths.filter((pathname) => pagesWarmMetadata.routePatterns[pathname] !== void 0);
 	const appOwnedWarmPaths = appDir ? await resolveAppWarmPaths({
 		appDir,
 		i18n: config.i18n,
@@ -828,19 +855,24 @@ async function discoverPrerenderPathManifest(options) {
 	}) : {
 		appPaths: [],
 		appRoutePaths: [],
-		htmlPaths: discoveredAppPaths,
-		loadingShellPaths: discoveredLoadingShellPaths,
-		pagesPaths: resolvedPagesWarmPaths,
-		routePatterns: pagesDir ? await resolvePagesWarmRoutePatterns({
-			i18n: config.i18n,
-			pagesDir,
-			pageExtensions: config.pageExtensions,
-			paths: resolvedPagesWarmPaths
-		}) : {},
-		rscPaths: discoveredAppPaths
+		htmlPaths: pagesOnlyWarmPaths,
+		loadingShellPaths: [],
+		pagesPaths: pagesOnlyWarmPaths,
+		routePatterns: pagesWarmMetadata.routePatterns,
+		rscPaths: []
 	};
-	const warmPaths = appDir ? appOwnedWarmPaths.htmlPaths : resolvedPagesWarmPaths;
-	const pagesOwnedWarmPaths = appDir ? appOwnedWarmPaths.pagesPaths : resolvedPagesWarmPaths;
+	for (const pathname of configuredCandidatePaths) {
+		if (appOwnedWarmPaths.routePatterns[pathname] || !routeMayResolveWarmPathSet.has(pathname) && !requestStageMayTerminateWarmPathSet.has(pathname)) continue;
+		appOwnedWarmPaths.htmlPaths.push(pathname);
+		(appDir ? appOwnedWarmPaths.appPaths : appOwnedWarmPaths.pagesPaths).push(pathname);
+		if (appDir && routeMayResolveWarmPathSet.has(pathname)) appOwnedWarmPaths.rscPaths.push(pathname);
+		appOwnedWarmPaths.routePatterns[pathname] = {
+			kind: appDir ? "app-page" : "pages-page",
+			pattern: pathname
+		};
+	}
+	const warmPaths = appOwnedWarmPaths.htmlPaths;
+	const pagesOwnedWarmPaths = appOwnedWarmPaths.pagesPaths;
 	const resolvedPagesDataWarmPaths = pagesOwnedWarmPaths.filter((pathname) => discoveredPagesDataPathSet.has(pathname));
 	const pagesDataPaths = resolvedPagesDataWarmPaths.map((pathname) => buildPagesDataHref(config.basePath, config.buildId, localizePagesDataPath(pathname, config.i18n), ""));
 	const routePatterns = annotateCacheabilityProbeSafety(appOwnedWarmPaths.routePatterns, config, routeMayResolveWarmPathSet, requestStageMayTerminateWarmPathSet, (name) => name.trim().toLowerCase() === "cache-control" || options.isResponsePolicyHeader?.(name) === true);

package/dist/build/prerender.d.ts

@@ -41,7 +41,7 @@ export type PrerenderRouteResult = {
 } | {
   route: string;
   status: "skipped";
-  reason: "ssr" | "dynamic" | "no-static-params" | "api" | "internal";
+  reason: "ssr" | "dynamic" | "no-static-params" | "empty-static-params" | "api" | "internal";
 } | {
   route: string;
   status: "error";

package/dist/build/prerender.js

@@ -708,7 +708,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					results.push({
 						route: route.pattern,
 						status: "skipped",
-						reason: "no-static-params"
+						reason: "empty-static-params"
 					});
 					continue;
 				}

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

@@ -25,8 +25,8 @@ export type CdnCacheAdapterCapabilities = {
    * variants when this guarantee is present.
    */
   responseVary?: "verbatim";
-  /** Warm by observing after-render `X-Vinext-Cache` admission from Response Store. */
-  warmup?: "response-store";
+  /** Warm by observing framework `X-Vinext-Cache` admission instead of an edge-cache header. */
+  warmup?: "data-cache" | "response-store";
   /**
    * Rewrites and other request routing run before the shared response stage,
    * and the resolved response-stage invocation participates in cache identity.
@@ -81,7 +81,7 @@ export type CacheAdapterDescriptor<O extends Record<string, unknown> = Record<st
 };
 export declare function hasVerbatimResponseVary(cache?: VinextCacheConfig | null): boolean;
 export declare function supportsCanonicalRscWarmup(cache?: VinextCacheConfig | null): boolean;
-export declare function usesVinextCacheWarmupStatus(cache?: VinextCacheConfig | null): boolean;
+export declare function cacheWarmupStatusSource(cache?: VinextCacheConfig | null): "cloudflare" | "data-cache" | "vinext";
 export declare function hasUncachedRequestRouting(cache?: VinextCacheConfig | null): boolean;
 export declare function hasBuildIdentityResponseHeader(cache?: VinextCacheConfig | null): boolean;
 export declare function requiresRouteCacheabilityProbeManifest(cache?: VinextCacheConfig | null): boolean;

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

@@ -22,14 +22,16 @@ function hasVerbatimResponseVary(cache) {
 function supportsCanonicalRscWarmup(cache) {
 	return hasVerbatimResponseVary(cache);
 }
-function usesVinextCacheWarmupStatus(cache) {
-	return cache?.cdn?.capabilities?.warmup === "response-store";
+function cacheWarmupStatusSource(cache) {
+	if (cache?.cdn?.capabilities?.warmup === "response-store") return "vinext";
+	if (!cache?.cdn?.adapter && cache?.data?.capabilities?.warmup === "data-cache") return "data-cache";
+	return "cloudflare";
 }
 function hasUncachedRequestRouting(cache) {
 	return cache?.cdn?.capabilities?.requestRouting === "uncached-stage";
 }
 function hasBuildIdentityResponseHeader(cache) {
-	return cache?.cdn?.capabilities?.buildIdentity === "response-header";
+	return cache?.cdn?.capabilities?.buildIdentity === "response-header" || !cache?.cdn?.adapter && cache?.data?.capabilities?.buildIdentity === "response-header";
 }
 function requiresRouteCacheabilityProbeManifest(cache) {
 	return cache?.cdn?.capabilities?.routeCacheability === "probe-manifest";
@@ -79,6 +81,7 @@ function inlineOptions(adapter, options) {
 function generateCacheAdaptersModule(cache) {
 	const data = cache?.data;
 	const cdn = cache?.cdn;
+	const dataProvidesBuildIdentity = !cdn?.adapter && data?.capabilities?.buildIdentity === "response-header";
 	if (!data?.adapter && !cdn?.adapter) return [
 		"// vinext: no cache.cdn/cache.data adapter configured — registration is a no-op.",
 		"export function registerConfiguredCacheAdapters() {}",
@@ -92,16 +95,20 @@ function generateCacheAdaptersModule(cache) {
 	if (cdn?.adapter) {
 		lines.push(`import __vinextCdnAdapterFactory from ${JSON.stringify(cdn.adapter)};`);
 		lines.push(`import { registerCdnCacheAdapter } from "vinext/shims/cdn-cache-state";`);
-	}
+	} else if (dataProvidesBuildIdentity) lines.push(`import { DefaultCdnCacheAdapter } from "vinext/shims/cdn-cache";`, `import { registerCdnCacheAdapter } from "vinext/shims/cdn-cache-state";`);
 	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 {", `    registerDataCacheHandler(() => __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 (data?.adapter) {
+		lines.push("  try {", `    registerDataCacheHandler(() => __vinextDataAdapterFactory({ env, options: ${inlineOptions(data.adapter, data.options)} }));`);
+		if (dataProvidesBuildIdentity) lines.push("    registerCdnCacheAdapter(() => new DefaultCdnCacheAdapter(", "      process.env.__VINEXT_RSC_BUILD_IDENTITY || process.env.__VINEXT_BUILD_ID,", "    ));");
+		lines.push("  } 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 {", `    registerCdnCacheAdapter(() => __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");
 }
 /** Generate request-stage registration without importing a configured data adapter. */
 function generateCdnCacheAdapterModule(cache) {
-	return `${generateCacheAdaptersModule(cache?.cdn ? { cdn: cache.cdn } : void 0)}export const hasConfiguredDataCache = ${Boolean(cache?.data?.adapter)};\n`;
+	return `${generateCacheAdaptersModule(cache?.cdn ? { cdn: cache.cdn } : void 0)}export const hasConfiguredDataCache = ${Boolean(cache?.data?.adapter)};\nexport const configuredCdnCacheAdapterOptions = ${inlineOptions(cache?.cdn?.adapter ?? "cdn", cache?.cdn?.options)};\n`;
 }
 //#endregion
-export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, VIRTUAL_CDN_CACHE_ADAPTER, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, generateCdnCacheAdapterModule, hasBuildIdentityResponseHeader, hasUncachedRequestRouting, hasVerbatimResponseVary, isConfiguredCdnResponsePolicyHeader, loadVinextCacheConfigFromViteConfig, requiresRouteCacheabilityProbeManifest, supportsCanonicalRscWarmup, usesVinextCacheWarmupStatus };
+export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, VIRTUAL_CDN_CACHE_ADAPTER, cacheWarmupStatusSource, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, generateCdnCacheAdapterModule, hasBuildIdentityResponseHeader, hasUncachedRequestRouting, hasVerbatimResponseVary, isConfiguredCdnResponsePolicyHeader, loadVinextCacheConfigFromViteConfig, requiresRouteCacheabilityProbeManifest, supportsCanonicalRscWarmup };

package/dist/check.js

@@ -1,5 +1,7 @@
+import { __toESM } from "./_virtual/_rolldown/runtime.js";
 import path from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { detectPackageManager, findDir } from "./utils/project.js";
+import { require_ignore } from "./deps/.pnpm/ignore@5.3.2/deps/ignore/index.js";
 import fs from "node:fs";
 import { parseAst } from "vite";
 //#region src/check.ts
@@ -9,6 +11,7 @@ import { parseAst } from "vite";
 * Scans an existing Next.js app and produces a compatibility report
 * showing what will work, what needs changes, and an overall score.
 */
+var import_ignore = /* @__PURE__ */ __toESM(require_ignore(), 1);
 /** Sort order for statuses: unsupported first, then partial, then supported. */
 const STATUS_ORDER = {
 	unsupported: 0,
@@ -372,25 +375,69 @@ const LIBRARY_SUPPORT = {
 		detail: "works with D1 on Cloudflare Workers"
 	}
 };
-/**
-* Recursively find all source files in a directory.
-*/
-function findSourceFiles(dir, extensions = [
+const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+	"node_modules",
+	".next",
+	"dist",
+	".git"
+]);
+const SOURCE_EXTENSIONS = [
 	".ts",
 	".tsx",
 	".js",
 	".jsx",
 	".mjs"
-]) {
+];
+function readGitignoreRule(dir) {
+	const gitignore = path.join(dir, ".gitignore");
+	let stat;
+	try {
+		stat = fs.lstatSync(gitignore);
+	} catch {
+		return;
+	}
+	if (!stat.isFile()) return;
+	return {
+		dir,
+		matcher: (0, import_ignore.default)({ ignorecase: false }).add(fs.readFileSync(gitignore, "utf-8"))
+	};
+}
+function ancestorGitignoreRules(root, dir) {
+	const rules = [];
+	let current = root;
+	for (const segment of path.relative(root, dir).split("/")) {
+		const rule = readGitignoreRule(current);
+		if (rule) rules.push(rule);
+		current = path.join(current, segment);
+		if (isGitignored(current, true, rules)) break;
+	}
+	return rules;
+}
+function isGitignored(fullPath, isDirectory, rules) {
+	let ignored = false;
+	for (const rule of rules) {
+		const relative = path.relative(rule.dir, fullPath) + (isDirectory ? "/" : "");
+		const result = rule.matcher.test(relative);
+		if (result.ignored) ignored = true;
+		else if (result.unignored) ignored = false;
+	}
+	return ignored;
+}
+/**
+* Recursively find all source files in a directory.
+*/
+function findSourceFiles(dir, extensions = SOURCE_EXTENSIONS, inherited = []) {
 	const results = [];
 	if (!fs.existsSync(dir)) return results;
+	const localRule = readGitignoreRule(dir);
+	const rules = localRule ? [...inherited, localRule] : inherited;
 	const entries = fs.readdirSync(dir, { withFileTypes: true });
 	for (const entry of entries) {
 		const fullPath = path.join(dir, entry.name);
-		if (entry.isDirectory()) {
-			if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist" || entry.name === ".git") continue;
-			results.push(...findSourceFiles(fullPath, extensions));
-		} else if (extensions.some((ext) => entry.name.endsWith(ext))) results.push(fullPath);
+		if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name)) continue;
+		if (isGitignored(fullPath, entry.isDirectory(), rules)) continue;
+		if (entry.isDirectory()) results.push(...findSourceFiles(fullPath, extensions, rules));
+		else if (extensions.some((ext) => entry.name.endsWith(ext))) results.push(fullPath);
 	}
 	return results;
 }
@@ -400,12 +447,13 @@ function findSourceFiles(dir, extensions = [
 * rather than bundled into the vinext application, so reporting their imports
 * or CJS globals as migration blockers produces false positives.
 */
+function isRuntimeSourceFile(file) {
+	const basename = path.basename(file);
+	const isTestRunnerConfig = /^(?:jest|playwright|vitest)\.config\.[cm]?[jt]sx?$/.test(basename);
+	return !/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(basename) && !isTestRunnerConfig;
+}
 function findRuntimeSourceFiles(root) {
-	return findSourceFiles(root).filter((file) => {
-		const basename = path.basename(file);
-		const isTestRunnerConfig = /^(?:jest|playwright|vitest)\.config\.[cm]?[jt]sx?$/.test(basename);
-		return !/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(basename) && !isTestRunnerConfig;
-	});
+	return findSourceFiles(root).filter(isRuntimeSourceFile);
 }
 function isIdentStart(c) {
 	return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_" || c === "$";
@@ -839,6 +887,14 @@ function checkLibraries(root) {
 */
 function checkConventions(root) {
 	const items = [];
+	const sourceFiles = findSourceFiles(root);
+	const routeFiles = (dir) => {
+		const files = sourceFiles.filter((file) => file.startsWith(`${dir}/`));
+		if (files.length || !fs.lstatSync(dir).isSymbolicLink()) return files;
+		const rules = ancestorGitignoreRules(root, dir);
+		if (isGitignored(dir, true, rules)) return [];
+		return findSourceFiles(dir, SOURCE_EXTENSIONS, rules);
+	};
 	const pagesDir = findDir(root, "pages", "src/pages");
 	const appDirPath = findDir(root, "app", "src/app");
 	const hasProxy = fs.existsSync(path.join(root, "proxy.ts")) || fs.existsSync(path.join(root, "proxy.js"));
@@ -849,7 +905,7 @@ function checkConventions(root) {
 			name: isSrc ? "Pages Router (src/pages/)" : "Pages Router (pages/)",
 			status: "supported"
 		});
-		const pageFiles = findSourceFiles(pagesDir);
+		const pageFiles = routeFiles(pagesDir);
 		const pages = pageFiles.filter((f) => !f.includes("/api/") && !f.includes("_app") && !f.includes("_document") && !f.includes("_error"));
 		const apiRoutes = pageFiles.filter((f) => f.includes("/api/"));
 		items.push({
@@ -875,7 +931,7 @@ function checkConventions(root) {
 			name: isSrc ? "App Router (src/app/)" : "App Router (app/)",
 			status: "supported"
 		});
-		const appFiles = findSourceFiles(appDirPath);
+		const appFiles = routeFiles(appDirPath);
 		const pages = appFiles.filter((f) => isAppRouterFile(f, "page"));
 		const layouts = appFiles.filter((f) => isAppRouterFile(f, "layout"));
 		const routes = appFiles.filter((f) => f.endsWith("route.tsx") || f.endsWith("route.ts") || f.endsWith("route.js"));
@@ -928,11 +984,11 @@ function checkConventions(root) {
 			detail: "required for Vite — vinext init will add it automatically"
 		});
 	}
-	const allSourceFiles = findRuntimeSourceFiles(root);
+	const runtimeSourceFiles = sourceFiles.filter(isRuntimeSourceFile);
 	const viewTransitionRegex = /import\s+\{[^}]*\bViewTransition\b[^}]*\}\s+from\s+['"]react['"]/;
 	const viewTransitionFiles = [];
 	const cjsGlobalFiles = [];
-	for (const file of allSourceFiles) {
+	for (const file of runtimeSourceFiles) {
 		const content = fs.readFileSync(file, "utf-8");
 		const rel = path.relative(root, file);
 		if (viewTransitionRegex.test(content)) viewTransitionFiles.push(rel);

package/dist/client/dev-error-overlay.js

@@ -1,5 +1,5 @@
-import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
+import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
 import { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT } from "../utils/dev-stack-sourcemap-endpoint.js";
 import { dismissOverlay, expandOverlay, getOverlaySnapshot, minimizeOverlay, reportToOverlay, setOverlayIndex, subscribeOverlay, updateOverlayErrorStack } from "./dev-error-overlay-store.js";
 import { Fragment, useEffect, useMemo, useState, useSyncExternalStore } from "react";

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

@@ -321,6 +321,10 @@ export type ResolvedNextConfig = {
   resolveExtensions: string[] | null;
   serverResolveExtensions: string[] | null;
   instrumentationClientInject: string[];
+  /** Route manifest injected by Next.js-compatible instrumentation plugins. */
+  instrumentationClientRouteManifest: string | undefined;
+  /** Server globals injected into instrumentation.ts by wrapped webpack configs. */
+  instrumentationServerValueInjections: Record<string, unknown>;
   cacheComponents: boolean;
   appNavFailHandling: boolean;
   /**