vinext 0.1.2 → 0.1.4

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

@@ -7,6 +7,13 @@ type ClientAssetFileNameInfo = {
   readonly originalFileName?: string;
   readonly originalFileNames?: readonly string[];
 };
+type RscFrameworkModuleInfo = {
+  importers: string[];
+  isEntry: boolean;
+};
+type RscFrameworkManualChunksMeta = {
+  getModuleInfo(id: string): RscFrameworkModuleInfo | null;
+};
 /**
  * Routes client assets into Next-compatible subtrees: `.css` sources go to
  * `<assetsDir>/css/`, everything else to `<assetsDir>/media/`. Returned as a
@@ -80,18 +87,20 @@ declare function isRscFrameworkModule(id: string): boolean;
  * dedicated "framework" chunk in the RSC server build. Returns the bundler-
  * appropriate shape: rolldown's `codeSplitting` for Vite 8+, Rollup's
  * `manualChunks` for Vite 7. See {@link RSC_FRAMEWORK_CHUNK_TEST} for the
- * motivation (issue #1549).
+ * motivation (issue #1549). Framework modules that are only reachable through
+ * dynamic imports must stay out of the eager framework chunk (issue #2073).
  */
 declare function createRscFrameworkChunkOutputConfig(viteMajorVersion: number): {
   codeSplitting: {
     groups: {
       name: string;
       test: RegExp;
+      entriesAware: boolean;
     }[];
   };
   manualChunks?: undefined;
 } | {
-  manualChunks(id: string): string | undefined;
+  manualChunks(id: string, meta: RscFrameworkManualChunksMeta): string | undefined;
   codeSplitting?: undefined;
 };
 /**

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

@@ -33,9 +33,10 @@ function createClientAssetFileNames(assetsDir) {
 * (node_modules/.pnpm/pkg@ver/node_modules/pkg).
 */
 function getPackageName(id) {
-	const nmIdx = id.lastIndexOf("node_modules/");
+	const normalizedId = id.replaceAll("\\", "/");
+	const nmIdx = normalizedId.lastIndexOf("node_modules/");
 	if (nmIdx === -1) return null;
-	const rest = id.slice(nmIdx + 13);
+	const rest = normalizedId.slice(nmIdx + 13);
 	if (rest.startsWith("@")) {
 		const parts = rest.split("/");
 		return parts.length >= 2 ? parts[0] + "/" + parts[1] : null;
@@ -153,20 +154,30 @@ function isRscFrameworkModule(id) {
 	const pkg = getPackageName(id);
 	return pkg !== null && FRAMEWORK_PACKAGES.includes(pkg);
 }
+function isStaticallyReachableFromEntry(id, meta, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(id)) return false;
+	visited.add(id);
+	const moduleInfo = meta.getModuleInfo(id);
+	if (!moduleInfo) return false;
+	if (moduleInfo.isEntry) return true;
+	return moduleInfo.importers.some((importer) => isStaticallyReachableFromEntry(importer, meta, visited));
+}
 /**
 * Output config that isolates React (and the RSC flight runtime) into a
 * dedicated "framework" chunk in the RSC server build. Returns the bundler-
 * appropriate shape: rolldown's `codeSplitting` for Vite 8+, Rollup's
 * `manualChunks` for Vite 7. See {@link RSC_FRAMEWORK_CHUNK_TEST} for the
-* motivation (issue #1549).
+* motivation (issue #1549). Framework modules that are only reachable through
+* dynamic imports must stay out of the eager framework chunk (issue #2073).
 */
 function createRscFrameworkChunkOutputConfig(viteMajorVersion) {
 	if (viteMajorVersion >= 8) return { codeSplitting: { groups: [{
 		name: "framework",
-		test: RSC_FRAMEWORK_CHUNK_TEST
+		test: RSC_FRAMEWORK_CHUNK_TEST,
+		entriesAware: true
 	}] } };
-	return { manualChunks(id) {
-		return isRscFrameworkModule(id) ? "framework" : void 0;
+	return { manualChunks(id, meta) {
+		return isRscFrameworkModule(id) && isStaticallyReachableFromEntry(id, meta) ? "framework" : void 0;
 	} };
 }
 /**

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;
 						}
@@ -634,6 +659,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				for (const params of paramSets) {
 					if (params === null || params === void 0) throw new Error(`generateStaticParams() for ${route.pattern} returned an entry with no params object.`);
 					const urlPath = buildUrlFromParams(route.pattern, params);
+					if (queuedRouteUrls.has(urlPath)) continue;
 					queuedRouteUrls.add(urlPath);
 					urlsToRender.push({
 						urlPath,
@@ -642,7 +668,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 +676,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 +687,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 +712,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 +764,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 +800,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 +907,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/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/pages-router-link-navigation.d.ts

@@ -3,23 +3,49 @@ type PagesRouterLinkTransitionOptions = {
   scroll?: boolean;
   shallow?: boolean;
   locale?: string | false;
+  _vinextInterpolateDynamicRoute?: boolean;
 };
 type PagesRouterLinkRuntime = {
   push(url: string, as?: string, options?: PagesRouterLinkTransitionOptions): Promise<boolean>;
   replace(url: string, as?: string, options?: PagesRouterLinkTransitionOptions): Promise<boolean>;
 };
+type PagesRouterLinkNavigation = {
+  href: string;
+  replace: boolean;
+  scroll: boolean;
+  shallow?: boolean;
+  locale?: string | false;
+  interpolateDynamicRoute?: boolean;
+};
+declare function resolvePagesRouterQueryOnlyHref(href: string, {
+  asPath,
+  basePath,
+  fallbackHref,
+  locales
+}: {
+  asPath?: string;
+  basePath: string;
+  fallbackHref: string;
+  locales?: readonly string[];
+}): string;
 declare function navigatePagesRouterLink(router: PagesRouterLinkRuntime, {
   href,
   replace,
   scroll,
   shallow,
-  locale
+  locale,
+  interpolateDynamicRoute
+}: PagesRouterLinkNavigation): Promise<void>;
+declare function navigatePagesRouterLinkWithFallback({
+  router,
+  loadRouter,
+  navigation,
+  fallback
 }: {
-  href: string;
-  replace: boolean;
-  scroll: boolean;
-  shallow?: boolean;
-  locale?: string | false;
+  router?: PagesRouterLinkRuntime;
+  loadRouter: () => Promise<PagesRouterLinkRuntime | undefined>;
+  navigation: PagesRouterLinkNavigation;
+  fallback: () => void;
 }): Promise<void>;
 //#endregion
-export { navigatePagesRouterLink };
+export { navigatePagesRouterLink, navigatePagesRouterLinkWithFallback, resolvePagesRouterQueryOnlyHref };

package/dist/client/pages-router-link-navigation.js

@@ -1,12 +1,42 @@
+import { stripBasePath } from "../utils/base-path.js";
+import { getLocalePathPrefix } from "../utils/domain-locale.js";
 //#region src/client/pages-router-link-navigation.ts
-async function navigatePagesRouterLink(router, { href, replace, scroll, shallow, locale }) {
+function resolvePagesRouterQueryOnlyHref(href, { asPath, basePath, fallbackHref, locales }) {
+	if (!href.startsWith("?")) return href;
+	try {
+		const fallbackUrl = new URL(fallbackHref);
+		const base = new URL(asPath ?? `${stripBasePath(fallbackUrl.pathname, basePath)}${fallbackUrl.search}${fallbackUrl.hash}`, "http://vinext.local");
+		const locale = getLocalePathPrefix(base.pathname, locales);
+		if (locale) base.pathname = base.pathname.slice(locale.length + 1) || "/";
+		const resolved = new URL(href, base);
+		return resolved.href.slice(resolved.origin.length);
+	} catch {
+		return href;
+	}
+}
+async function navigatePagesRouterLink(router, { href, replace, scroll, shallow, locale, interpolateDynamicRoute = false }) {
 	const routerOptions = {
 		scroll,
 		locale
 	};
+	if (interpolateDynamicRoute) routerOptions._vinextInterpolateDynamicRoute = true;
 	if (shallow !== void 0) routerOptions.shallow = shallow;
 	if (replace) await router.replace(href, void 0, routerOptions);
 	else await router.push(href, void 0, routerOptions);
 }
+async function navigatePagesRouterLinkWithFallback({ router, loadRouter, navigation, fallback }) {
+	let pagesRouter = router;
+	if (!pagesRouter) try {
+		pagesRouter = await loadRouter();
+	} catch {
+		fallback();
+		return;
+	}
+	if (!pagesRouter) {
+		fallback();
+		return;
+	}
+	await navigatePagesRouterLink(pagesRouter, navigation);
+}
 //#endregion
-export { navigatePagesRouterLink };
+export { navigatePagesRouterLink, navigatePagesRouterLinkWithFallback, resolvePagesRouterQueryOnlyHref };

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/vinext-next-data.js

@@ -1,6 +1,8 @@
 import { isUnknownRecord } from "../utils/record.js";
 //#region src/client/vinext-next-data.ts
 function extractVinextNextDataJson(html) {
+	const canonical = /<script\b(?=[^>]*\bid=["']__NEXT_DATA__["'])(?=[^>]*\btype=["']application\/json["'])[^>]*>([\s\S]*?)<\/script>/.exec(html);
+	if (canonical) return canonical[1];
 	const assignment = /<script(?:\s[^>]*)?>\s*window\.__NEXT_DATA__\s*=\s*/.exec(html);
 	if (!assignment || assignment.index === void 0) return null;
 	let start = assignment.index + assignment[0].length;

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

@@ -163,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

@@ -148,6 +148,16 @@ declare function matchRedirect(pathname: string, redirects: NextRedirect[], ctx:
  * when evaluating rewrites, so this parameter is required.
  */
 declare function matchRewrite(pathname: string, rewrites: NextRewrite[], ctx: RequestContext, basePathState?: BasePathMatchState): string | null;
+/**
+ * Check whether a rewrite source can match a pathname without evaluating its
+ * request-dependent `has` / `missing` conditions.
+ *
+ * Dev uses this only as a conservative preflight before middleware runs. The
+ * conditions may become true after middleware overrides request headers, so
+ * evaluating them against the original request would incorrectly skip the
+ * Pages request pipeline for file-looking paths.
+ */
+declare function matchesRewriteSource(pathname: string, rewrite: NextRewrite, basePathState?: BasePathMatchState): boolean;
 /**
  * Sanitize a redirect/rewrite destination to collapse protocol-relative URLs.
  *
@@ -244,4 +254,4 @@ declare function applyLocaleToRoutes<T extends NextRedirect | NextRewrite>(route
   trailingSlash?: boolean;
 }): T[];
 //#endregion
-export { BasePathMatchState, RequestContext, applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
+export { BasePathMatchState, RequestContext, applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, matchesRewriteSource, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };