vinext 0.1.1 → 0.1.3

package/README.md

@@ -528,22 +528,19 @@ The cache is pluggable. The default `MemoryCacheHandler` works out of the box. S
 
 #### Configuring cache adapters from `vite.config`
 
-Instead of wiring up cache handlers imperatively from a worker entry, you can declare them in the `vinext()` plugin config. The `@vinext/cloudflare` package ships two Cloudflare adapters for this:
+Instead of wiring up cache handlers imperatively from a worker entry, you can declare them in the `vinext()` plugin config. The `@vinext/cloudflare` package ships Cloudflare adapters for this:
 
 - **`kvDataAdapter()`** (`@vinext/cloudflare/cache/kv-data-adapter`) — backs the `"use cache"` data cache with a Workers KV namespace.
-- **`cdnAdapter()`** (`@vinext/cloudflare/cache/cdn-adapter`) — backs full-route CDN caching with the Workers Cache API.
 
 ```ts
 import { defineConfig } from "vite";
 import vinext from "vinext";
-import { cdnAdapter } from "@vinext/cloudflare/cache/cdn-adapter";
 import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";
 
 export default defineConfig({
   plugins: [
     vinext({
       cache: {
-        cdn: cdnAdapter(),
         data: kvDataAdapter(),
       },
     }),
@@ -559,7 +556,7 @@ The KV data adapter reads `env[binding]` at runtime, so add the matching KV name
 }
 ```
 
-`binding` defaults to `VINEXT_KV_CACHE`, so `kvDataAdapter()` with no options works as long as that's your binding name. Other options: `appPrefix` (namespace cache keys to isolate multiple apps in one KV namespace), `ttlSeconds` (default KV `expirationTtl`, default 30 days), and `tagCacheTtlMs` (in-memory tag-invalidation cache TTL, default 5s). `cdnAdapter()` takes no options — it just needs the Workers Cache, which is always available on Workers.
+`binding` defaults to `VINEXT_KV_CACHE`, so `kvDataAdapter()` with no options works as long as that's your binding name. Other options: `appPrefix` (namespace cache keys to isolate multiple apps in one KV namespace), `ttlSeconds` (default KV `expirationTtl`, default 30 days), and `tagCacheTtlMs` (in-memory tag-invalidation cache TTL, default 5s).
 
 Each builder returns a plain, serializable `{ adapter, options }` descriptor — **it never touches the Workers runtime**, so nothing throws at build or dev time when bindings aren't available. The actual adapter (and its `env` binding lookup) is instantiated lazily on the first request.
 

package/dist/build/client-build-config.d.ts

@@ -51,10 +51,16 @@ declare function createClientManualChunks(shimsDir: string): (id: string) => str
  * compression efficiency — small files restart the compression dictionary,
  * adding ~5-15% wire overhead vs fewer larger chunks.
  */
+declare function createClientFileNameConfig(assetsDir: string): {
+  entryFileNames: string;
+  chunkFileNames: string;
+};
 declare function createClientOutputConfig(clientManualChunks: (id: string) => string | undefined, assetsDir: string): {
   assetFileNames: (assetInfo: ClientAssetFileNameInfo) => string;
   manualChunks: (id: string) => string | undefined;
   experimentalMinChunkSize: number;
+  entryFileNames: string;
+  chunkFileNames: string;
 };
 declare function createClientCodeSplittingConfig(clientManualChunks: (id: string) => string | undefined): {
   minSize: number;
@@ -155,4 +161,4 @@ type VinextBuildConfigWithLegacy = VinextBuildConfig & {
 declare function getBuildBundlerOptions(build: UserConfig["build"] | undefined): VinextBuildBundlerOptions | undefined;
 declare function withBuildBundlerOptions(viteMajorVersion: number, bundlerOptions: VinextBuildBundlerOptions): Partial<VinextBuildConfigWithLegacy>;
 //#endregion
-export { RSC_FRAMEWORK_CHUNK_TEST, clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, isRscFrameworkModule, withBuildBundlerOptions };
+export { RSC_FRAMEWORK_CHUNK_TEST, clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientFileNameConfig, createClientManualChunks, createClientOutputConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, isRscFrameworkModule, withBuildBundlerOptions };

package/dist/build/client-build-config.js

@@ -89,8 +89,16 @@ function createClientManualChunks(shimsDir) {
 * compression efficiency — small files restart the compression dictionary,
 * adding ~5-15% wire overhead vs fewer larger chunks.
 */
+function createClientFileNameConfig(assetsDir) {
+	const chunksDir = `${assetsDir}/chunks`;
+	return {
+		entryFileNames: `${chunksDir}/[name]-[hash].js`,
+		chunkFileNames: `${chunksDir}/[name]-[hash].js`
+	};
+}
 function createClientOutputConfig(clientManualChunks, assetsDir) {
 	return {
+		...createClientFileNameConfig(assetsDir),
 		assetFileNames: createClientAssetFileNames(assetsDir),
 		manualChunks: clientManualChunks,
 		experimentalMinChunkSize: 1e4
@@ -228,4 +236,4 @@ function withBuildBundlerOptions(viteMajorVersion, bundlerOptions) {
 	return viteMajorVersion >= 8 ? { rolldownOptions: bundlerOptions } : { rollupOptions: bundlerOptions };
 }
 //#endregion
-export { RSC_FRAMEWORK_CHUNK_TEST, clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, isRscFrameworkModule, withBuildBundlerOptions };
+export { RSC_FRAMEWORK_CHUNK_TEST, clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientFileNameConfig, createClientManualChunks, createClientOutputConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, isRscFrameworkModule, withBuildBundlerOptions };

package/dist/build/prerender.d.ts

@@ -22,7 +22,8 @@ type PrerenderRouteResult = {
    * Omitted for non-dynamic routes where pattern === path.
    */
   path?: string; /** Which router produced this route. Used by cache seeding. */
-  router: "app" | "pages";
+  router: "app" | "pages"; /** Set to true when this is a PPR fallback shell. */
+  fallback?: boolean;
 } | {
   route: string;
   status: "skipped";
@@ -31,6 +32,13 @@ type PrerenderRouteResult = {
   route: string;
   status: "error";
   error: string;
+  /**
+   * Set when the error must fail the build in ALL modes (default included),
+   * not just `output: 'export'`. Used for a thrown generateStaticParams /
+   * getStaticPaths, which Next.js treats as a fatal build error rather than a
+   * silently-skipped route. Refs cloudflare/vinext#1982
+   */
+  fatal?: true;
 };
 /** Called after each route is resolved (rendered, skipped, or error). */
 type PrerenderProgressCallback = (update: {

package/dist/build/prerender.js

@@ -7,11 +7,11 @@ import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from
 import { BLOCKED_PAGES } from "../shims/constants.js";
 import { concatUint8Arrays, decodeRscEmbeddedChunk } from "../server/app-rsc-embedded-chunks.js";
 import { navigationRuntimeRscBootstrapExpression } from "../server/app-ssr-stream.js";
+import { createAppPprFallbackShells, markAppPprDynamicFallbackShellHtml } from "../server/app-ppr-fallback-shell.js";
 import { encodePrerenderRouteParams, serializePrerenderRouteParamsHeader } from "../server/prerender-route-params.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
 import { startProdServer } from "../server/prod-server.js";
-import { createAppPprFallbackShells } from "../server/app-ppr-fallback-shell.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -33,9 +33,21 @@ import os from "node:os";
 *   'default'  — skips SSR routes (served at request time); ISR routes rendered
 *   'export'   — SSR routes are build errors; ISR treated as static (no revalidate)
 */
+const EXPERIMENTAL_PPR_FALLBACK_SHELLS_ENV = "__VINEXT_EXPERIMENTAL_PPR_FALLBACK_SHELLS";
+function isExperimentalPprFallbackShellGenerationEnabled(env = process.env) {
+	return env[EXPERIMENTAL_PPR_FALLBACK_SHELLS_ENV] === "1";
+}
 function getErrorMessageWithStack(err) {
 	return err.stack || err.message;
 }
+var PrerenderUserFunctionError = class extends Error {};
+function parsePrerenderEndpointError(text) {
+	try {
+		const parsed = JSON.parse(text);
+		if (parsed && typeof parsed === "object" && "error" in parsed) return typeof parsed.error === "string" && parsed.error.length > 0 ? parsed.error : "Unknown prerender endpoint error";
+	} catch {}
+	return text || "Unknown prerender endpoint error";
+}
 /** Sentinel path used to trigger 404 rendering without a real route match. */
 const NOT_FOUND_SENTINEL_PATH = "/__vinext_nonexistent_for_404__";
 const DEFAULT_CONCURRENCY = Math.min(os.availableParallelism(), 8);
@@ -275,6 +287,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 				const res = await fetch(`${baseUrl}/__vinext/prerender/pages-static-paths?${search}`, { headers: secretHeaders });
 				const text = await res.text();
 				if (!res.ok) {
+					if (res.status === 500) throw new PrerenderUserFunctionError(parsePrerenderEndpointError(text));
 					console.warn(`[vinext] Warning: /__vinext/prerender/pages-static-paths returned ${res.status} for ${r.pattern}. Dynamic paths will be skipped. This may indicate a stale or missing prerender secret.`);
 					return {
 						paths: [],
@@ -322,10 +335,21 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 					});
 					continue;
 				}
-				const pathsResult = await route.module.getStaticPaths({
-					locales: [],
-					defaultLocale: ""
-				});
+				let pathsResult;
+				try {
+					pathsResult = await route.module.getStaticPaths({
+						locales: [],
+						defaultLocale: ""
+					});
+				} catch (e) {
+					results.push({
+						route: route.pattern,
+						status: "error",
+						error: `Failed to call getStaticPaths(): ${e.message}`,
+						...e instanceof PrerenderUserFunctionError ? { fatal: true } : {}
+					});
+					continue;
+				}
 				const fallback = pathsResult?.fallback ?? false;
 				if (mode === "export" && fallback !== false) {
 					results.push({
@@ -521,6 +545,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						const res = await fetch(`${baseUrl}/__vinext/prerender/static-params?${search}`, { headers: secretHeaders });
 						const text = await res.text();
 						if (!res.ok) {
+							if (res.status === 500) throw new PrerenderUserFunctionError(parsePrerenderEndpointError(text));
 							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;
 						}
@@ -642,7 +667,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						revalidate,
 						isSpeculative: false
 					});
-					if (config.cacheComponents === true) for (const fallbackShell of createAppPprFallbackShells(route, params)) {
+					if (config.cacheComponents === true && isExperimentalPprFallbackShellGenerationEnabled()) for (const fallbackShell of createAppPprFallbackShells(route, params)) {
 						if (queuedRouteUrls.has(fallbackShell.pathname)) continue;
 						queuedRouteUrls.add(fallbackShell.pathname);
 						urlsToRender.push({
@@ -650,7 +675,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 							routePattern: route.pattern,
 							prerenderRouteParams: encodePrerenderRouteParams(route.pattern, fallbackShell.params, fallbackShell.fallbackParamNames),
 							revalidate,
-							isSpeculative: false
+							isSpeculative: false,
+							isFallback: true
 						});
 					}
 				}
@@ -660,7 +686,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				results.push({
 					route: route.pattern,
 					status: "error",
-					error: `Failed to call generateStaticParams(): ${detail}`
+					error: `Failed to call generateStaticParams(): ${detail}`,
+					...e instanceof PrerenderUserFunctionError ? { fatal: true } : {}
 				});
 			}
 			else if (type === "unknown") urlsToRender.push({
@@ -684,7 +711,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 		* exactly once per URL after this function returns, keeping the callback
 		* at a single, predictable call site.
 		*/
-		async function renderUrl({ urlPath, routePattern, prerenderRouteParams, revalidate, isSpeculative }) {
+		async function renderUrl({ urlPath, routePattern, prerenderRouteParams, revalidate, isSpeculative, isFallback }) {
 			try {
 				const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParams);
 				const htmlHeaders = new Headers();
@@ -736,7 +763,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					status: "error",
 					error: "RSC handler returned no prerender HTML"
 				};
-				const html = htmlRender.html;
+				const html = isFallback ? markAppPprDynamicFallbackShellHtml(htmlRender.html) : htmlRender.html;
 				let rscData = extractRscPayloadFromPrerenderedHtml(html);
 				if (rscData === null) {
 					const rscHeaders = new Headers({
@@ -772,7 +799,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					revalidate: renderedRevalidate,
 					...typeof renderedRevalidate === "number" ? { expire: renderedCacheControl.expire } : {},
 					router: "app",
-					...urlPath !== routePattern ? { path: urlPath } : {}
+					...urlPath !== routePattern ? { path: urlPath } : {},
+					...isFallback ? { fallback: true } : {}
 				};
 			} catch (e) {
 				if (isSpeculative) return {
@@ -878,7 +906,8 @@ function writePrerenderIndex(routes, outDir, options) {
 			revalidate: r.revalidate,
 			...typeof r.revalidate === "number" ? { expire: r.expire } : {},
 			router: r.router,
-			...r.path ? { path: r.path } : {}
+			...r.path ? { path: r.path } : {},
+			...r.fallback ? { fallback: true } : {}
 		};
 		if (r.status === "skipped") return {
 			route: r.route,

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

@@ -1,5 +1,5 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
-import { PrerenderResult } from "./prerender.js";
+import { PrerenderResult, PrerenderRouteResult } from "./prerender.js";
 
 //#region src/build/run-prerender.d.ts
 type RunPrerenderOptions = {
@@ -48,6 +48,14 @@ type RunPrerenderOptions = {
  * If a required production bundle does not exist, an error is thrown directing
  * the user to run `vinext build` first.
  */
+/**
+ * Throw if any route is a `fatal` error (a thrown generateStaticParams /
+ * getStaticPaths). These fail the build in ALL modes — default included —
+ * matching `next build`, unlike intentionally-skipped dynamic/SSR routes and
+ * non-fatal errors (e.g. transport failures), which only fail under
+ * `output: 'export'`. Exported for direct unit testing. Refs cloudflare/vinext#1982
+ */
+declare function assertNoFatalPrerenderRoutes(routes: readonly PrerenderRouteResult[]): void;
 declare function runPrerender(options: RunPrerenderOptions): Promise<PrerenderResult | null>;
 //#endregion
-export { runPrerender };
+export { assertNoFatalPrerenderRoutes, runPrerender };

package/dist/build/run-prerender.js

@@ -82,6 +82,19 @@ function readBuiltBuildId(serverDir) {
 * If a required production bundle does not exist, an error is thrown directing
 * the user to run `vinext build` first.
 */
+/**
+* Throw if any route is a `fatal` error (a thrown generateStaticParams /
+* getStaticPaths). These fail the build in ALL modes — default included —
+* matching `next build`, unlike intentionally-skipped dynamic/SSR routes and
+* non-fatal errors (e.g. transport failures), which only fail under
+* `output: 'export'`. Exported for direct unit testing. Refs cloudflare/vinext#1982
+*/
+function assertNoFatalPrerenderRoutes(routes) {
+	const fatalRoutes = routes.filter((r) => r.status === "error" && r.fatal === true);
+	if (fatalRoutes.length === 0) return;
+	const fatalList = fatalRoutes.map((r) => `  ${r.route}: ${r.error}`).join("\n");
+	throw new Error(`Prerender failed: ${fatalRoutes.length} route${fatalRoutes.length !== 1 ? "s" : ""} errored during static generation.\n${fatalList}`);
+}
 async function runPrerender(options) {
 	const { root } = options;
 	const appDir = findDir(root, "app", "src/app");
@@ -197,6 +210,7 @@ async function runPrerender(options) {
 	} finally {
 		progress.finish(rendered, skipped, errors);
 	}
+	assertNoFatalPrerenderRoutes(allRoutes);
 	if (mode === "export" && errors > 0) {
 		const errorRoutes = allRoutes.filter((r) => r.status === "error").map((r) => `  ${r.route}: ${r.error}`).join("\n");
 		throw new Error(`Static export failed: ${errors} route${errors !== 1 ? "s" : ""} cannot be statically exported.\n${errorRoutes}\n\nRemove server-side data fetching (getServerSideProps, force-dynamic, revalidate) from these routes, or remove \`output: "export"\` from next.config.js.`);
@@ -207,4 +221,4 @@ async function runPrerender(options) {
 	};
 }
 //#endregion
-export { runPrerender };
+export { assertNoFatalPrerenderRoutes, runPrerender };

package/dist/check.js

@@ -1,4 +1,5 @@
 import { detectPackageManager } from "./utils/project.js";
+import { normalizePathSeparators } from "./utils/path.js";
 import fs from "node:fs";
 import path from "node:path";
 import { parseAst } from "vite";
@@ -342,7 +343,7 @@ function findSourceFiles(dir, extensions = [
 	if (!fs.existsSync(dir)) return results;
 	const entries = fs.readdirSync(dir, { withFileTypes: true });
 	for (const entry of entries) {
-		const fullPath = path.join(dir, entry.name);
+		const fullPath = normalizePathSeparators(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));
@@ -563,7 +564,7 @@ function scanImports(root) {
 			if (mod.startsWith("next/") || mod === "next" || mod === "server-only" || mod === "client-only") {
 				const normalized = mod === "next" ? "next" : mod;
 				if (!importUsage.has(normalized)) importUsage.set(normalized, []);
-				const relFile = path.relative(root, file);
+				const relFile = normalizePathSeparators(path.relative(root, file));
 				const usedInFiles = importUsage.get(normalized) ?? [];
 				if (!usedInFiles.includes(relFile)) usedInFiles.push(relFile);
 			}
@@ -876,7 +877,7 @@ function checkConventions(root) {
 	const cjsGlobalFiles = [];
 	for (const file of allSourceFiles) {
 		const content = fs.readFileSync(file, "utf-8");
-		const rel = path.relative(root, file);
+		const rel = normalizePathSeparators(path.relative(root, file));
 		if (viewTransitionRegex.test(content)) viewTransitionFiles.push(rel);
 		if (hasFreeCjsGlobal(content)) cjsGlobalFiles.push(rel);
 	}

package/dist/client/app-nav-failure-handler.d.ts

@@ -0,0 +1,8 @@
+//#region src/client/app-nav-failure-handler.d.ts
+declare function stageAppNavigationFailureTarget(href: string): void;
+declare function getAppNavigationFailureTarget(href: string): URL | null;
+declare function clearAppNavigationFailureTarget(target?: string | URL): void;
+declare function handleAppNavigationFailure(error: unknown): boolean;
+declare function installAppNavigationFailureListeners(): () => void;
+//#endregion
+export { clearAppNavigationFailureTarget, getAppNavigationFailureTarget, handleAppNavigationFailure, installAppNavigationFailureListeners, stageAppNavigationFailureTarget };

package/dist/client/app-nav-failure-handler.js

@@ -0,0 +1,44 @@
+import { installWindowNext } from "./window-next.js";
+//#region src/client/app-nav-failure-handler.ts
+function getPendingUrl() {
+	if (typeof window === "undefined") return null;
+	return window.next?.__pendingUrl ?? null;
+}
+function stageAppNavigationFailureTarget(href) {
+	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return;
+	installWindowNext({ __pendingUrl: new URL(href, window.location.href) });
+}
+function getAppNavigationFailureTarget(href) {
+	const pendingUrl = getPendingUrl();
+	if (pendingUrl === null || typeof window === "undefined") return null;
+	return pendingUrl.href === new URL(href, window.location.href).href ? pendingUrl : null;
+}
+function clearAppNavigationFailureTarget(target) {
+	if (typeof window === "undefined" || window.next?.__pendingUrl === void 0) return;
+	if (target instanceof URL) {
+		if (window.next.__pendingUrl !== target) return;
+	} else if (target !== void 0 && window.next.__pendingUrl.href !== new URL(target, window.location.href).href) return;
+	delete window.next.__pendingUrl;
+}
+function handleAppNavigationFailure(error) {
+	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return false;
+	const pendingUrl = getPendingUrl();
+	if (pendingUrl === null || pendingUrl.href === window.location.href) return false;
+	console.error("Error occurred during navigation, falling back to hard navigation", error);
+	window.location.assign(pendingUrl.href);
+	return true;
+}
+function installAppNavigationFailureListeners() {
+	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return () => {};
+	const listener = (event) => {
+		handleAppNavigationFailure("reason" in event ? event.reason : event.error);
+	};
+	window.addEventListener("error", listener);
+	window.addEventListener("unhandledrejection", listener);
+	return () => {
+		window.removeEventListener("error", listener);
+		window.removeEventListener("unhandledrejection", listener);
+	};
+}
+//#endregion
+export { clearAppNavigationFailureTarget, getAppNavigationFailureTarget, handleAppNavigationFailure, installAppNavigationFailureListeners, stageAppNavigationFailureTarget };

package/dist/client/navigation-runtime.d.ts

@@ -15,12 +15,13 @@ type NavigationRuntimeRscBootstrap = {
 };
 type NavigationRuntimeKind = "navigate" | "traverse" | "refresh";
 type NavigationRuntimeHistoryUpdateMode = "push" | "replace";
+type NavigationRuntimeVisibleCommitMode = "transition" | "synchronous";
 type NavigationRuntimeTraversalIntent = {
   direction: "back" | "forward" | "unknown";
   historyState: unknown;
   targetHistoryIndex: number | null;
 };
-type NavigationRuntimeNavigate = (href: string, redirectDepth?: number, navigationKind?: NavigationRuntimeKind, historyUpdateMode?: NavigationRuntimeHistoryUpdateMode, previousNextUrlOverride?: string | null, programmaticTransition?: boolean, traversalIntent?: NavigationRuntimeTraversalIntent, scrollIntent?: AppRouterScrollIntent | null) => Promise<void>;
+type NavigationRuntimeNavigate = (href: string, redirectDepth?: number, navigationKind?: NavigationRuntimeKind, historyUpdateMode?: NavigationRuntimeHistoryUpdateMode, previousNextUrlOverride?: string | null, programmaticTransition?: boolean, traversalIntent?: NavigationRuntimeTraversalIntent, scrollIntent?: AppRouterScrollIntent | null, visibleCommitMode?: NavigationRuntimeVisibleCommitMode) => Promise<void>;
 type NavigationRuntimeFunctions = {
   clearNavigationCaches?: () => void;
   commitHashNavigation?: (href: string, historyUpdateMode: NavigationRuntimeHistoryUpdateMode, scroll: boolean) => void;
@@ -66,4 +67,4 @@ declare function hasAppNavigationRuntime(): boolean;
  */
 declare function hasAppNavigationRuntimeBootstrap(): boolean;
 //#endregion
-export { NAVIGATION_RUNTIME_KEY, NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION, NavigationRuntime, NavigationRuntimeBootstrap, NavigationRuntimeFunctions, NavigationRuntimeNavigate, NavigationRuntimeRscBootstrap, NavigationRuntimeRscChunk, NavigationRuntimeSnapshot, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions, subscribeNavigationRuntimeRscChunk };
+export { NAVIGATION_RUNTIME_KEY, NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION, NavigationRuntime, NavigationRuntimeBootstrap, NavigationRuntimeFunctions, NavigationRuntimeNavigate, NavigationRuntimeRscBootstrap, NavigationRuntimeRscChunk, NavigationRuntimeSnapshot, NavigationRuntimeVisibleCommitMode, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions, subscribeNavigationRuntimeRscChunk };

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

@@ -3,6 +3,23 @@ import { NEXT_DATA } from "../shims/internal/utils.js";
 //#region src/client/vinext-next-data.d.ts
 type VinextLinkPrefetchRoute = {
   canPrefetchLoadingShell: boolean;
+  documentOnly?: boolean;
+  isDynamic: boolean;
+  patternParts: string[];
+};
+/**
+ * Pages Router route pattern exposed to the client so the App Router's
+ * navigation runtime can decide whether a soft-navigated URL should be
+ * handled by Pages (hard nav) or App (RSC). Mirrors the public shape of
+ * `VinextLinkPrefetchRoute` so a single trie matcher handles both.
+ *
+ * `canPrefetchLoadingShell` is always `false` for Pages routes — Pages
+ * does not have a separate loading boundary and its prefetch surface is
+ * `_next/data/<buildId>/<page>.json`.
+ */
+type VinextPagesLinkPrefetchRoute = {
+  canPrefetchLoadingShell: false;
+  documentOnly?: boolean;
   isDynamic: boolean;
   patternParts: string[];
 };
@@ -24,4 +41,4 @@ declare function extractVinextNextDataJson(html: string): string | null;
 declare function parseVinextNextDataJson(json: string): BrowserVinextNextData;
 declare function applyVinextLocaleGlobals(target: VinextLocaleGlobalTarget, nextData: VinextNextData): void;
 //#endregion
-export { VinextLinkPrefetchRoute, VinextNextData, applyVinextLocaleGlobals, extractVinextNextDataJson, parseVinextNextDataJson };
+export { VinextLinkPrefetchRoute, VinextNextData, VinextPagesLinkPrefetchRoute, applyVinextLocaleGlobals, extractVinextNextDataJson, parseVinextNextDataJson };

package/dist/client/window-next.d.ts

@@ -40,10 +40,9 @@
  * `window.next.router`. Mirrors the `publicAppRouterInstance` shape from
  * `packages/next/src/client/components/app-router-instance.ts`.
  *
- * `hmrRefresh` and `experimental_gesturePush` are intentionally omitted —
- * vinext does not implement them. Library callers that branch on their
- * presence (`typeof router.hmrRefresh === "function"`) will skip the
- * branch, matching what they would do on a production Next.js build.
+ * `hmrRefresh` is intentionally omitted — vinext does not implement it.
+ * `experimental_gesturePush` is attached only when
+ * `experimental.gestureTransition` is enabled, matching Next.js.
  */
 type AppRouterPublicInstance = {
   push: (href: string, options?: {
@@ -57,6 +56,9 @@ type AppRouterPublicInstance = {
   refresh: () => void;
   prefetch: (href: string, options?: {
     onInvalidate?: () => void;
+  }) => void;
+  experimental_gesturePush?: (href: string, options?: {
+    scroll?: boolean;
   }) => void; /** Default placeholder, matches Next.js. */
   bfcacheId?: string;
 };
@@ -161,5 +163,6 @@ type WindowNext = {
  * resets state.
  */
 declare function installWindowNext(fields: Partial<WindowNext>): void;
+declare function setWindowNextInternalSourcePage(sourcePage: string | null): void;
 //#endregion
-export { PagesRouterPublicInstance, installWindowNext };
+export { PagesRouterPublicInstance, installWindowNext, setWindowNextInternalSourcePage };

package/dist/client/window-next.js

@@ -42,5 +42,16 @@ function installWindowNext(fields) {
 		...fields
 	};
 }
+function setWindowNextInternalSourcePage(sourcePage) {
+	if (typeof window === "undefined") return;
+	installWindowNext({});
+	if (sourcePage === null) {
+		delete window.next?.__internal_src_page;
+		return;
+	}
+	const next = window.next;
+	if (!next) return;
+	next.__internal_src_page = sourcePage;
+}
 //#endregion
-export { installWindowNext };
+export { installWindowNext, setWindowNextInternalSourcePage };

package/dist/cloudflare/src/cache/cdn-adapter.runtime.js

@@ -73,7 +73,12 @@ var CloudflareCdnCacheAdapter = class {
 	async set(_key, _data, _ctx) {}
 	buildResponseHeaders(input) {
 		if (!input.cacheControl) return { "Cache-Control": NO_STORE };
-		if (/\b(?:no-store|no-cache|private)\b/.test(input.cacheControl)) return { "Cache-Control": input.cacheControl };
+		if (/\b(?:no-store|no-cache|private)\b/.test(input.cacheControl)) return {
+			"Cache-Control": input.cacheControl,
+			"CDN-Cache-Control": null,
+			"Cloudflare-CDN-Cache-Control": null,
+			"Cache-Tag": null
+		};
 		const headers = {
 			"Cache-Control": BROWSER_REVALIDATE,
 			"CDN-Cache-Control": toEdgeCacheControl(input.cacheControl)

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

@@ -32,10 +32,10 @@ declare function escapeHeaderSource(source: string): string;
  * Callers extract the relevant parts from the incoming Request.
  */
 type RequestContext = {
-  headers: Headers;
-  cookies: Record<string, string>;
-  query: URLSearchParams;
-  host: string;
+  readonly headers: Headers;
+  readonly cookies: Record<string, string>;
+  readonly query: URLSearchParams;
+  readonly host: string;
 };
 /**
  * basePath gating state passed alongside the pathname to every matcher.
@@ -65,6 +65,13 @@ type BasePathMatchState = {
 declare function parseCookies(cookieHeader: string | null): Record<string, string>;
 /**
  * Build a RequestContext from a Web Request object.
+ *
+ * `cookies` and `query` are lazy memoized getters: they are consumed only by
+ * `has`/`missing` condition evaluation (`checkHasConditions` /
+ * `matchesRuleConditions`), and most apps configure no such conditions. The
+ * cookie split and `searchParams` access are therefore deferred until first
+ * read and computed at most once. Mirrors `headersContextFromRequest` in
+ * `shims/headers.ts`.
  */
 declare function requestContextFromRequest(request: Request): RequestContext;
 declare function normalizeHost(hostHeader: string | null, fallbackHostname: string): string;