cloudflare · NathanDrake2406 · Aug 23, 2026 · Aug 23, 2026 · Aug 24, 2026 · Aug 24, 2026
diff --git a/packages/vinext/src/build/prerender.ts b/packages/vinext/src/build/prerender.ts
@@ -44,6 +44,7 @@ import {
   VINEXT_PRERENDER_CACHE_LIFE_HEADER,
   VINEXT_PRERENDER_METADATA_ROUTES_PATH,
   VINEXT_PRERENDER_RENDER_ERROR_HEADER,
+  VINEXT_PRERENDER_SHARED_CACHE_BYPASS_HEADER,
   VINEXT_PRERENDER_ROUTE_PARAMS_HEADER,
   VINEXT_PRERENDER_SECRET_HEADER,
   VINEXT_PRERENDER_SPECULATIVE_HEADER,
@@ -209,6 +210,28 @@ type PrerenderProgressCallback = (update: {
   status: PrerenderRouteResult["status"];
 }) => void;
 
+function nonCacheablePagesResult(
+  mode: PrerenderOptions["mode"],
+  route: string,
+  path = route,
+): PrerenderRouteResult {
+  if (mode === "export") {
+    return {
+      route,
+      status: "error",
+      error:
+        "Page returned an explicitly non-cacheable response which is not supported with output: 'export'",
+    };
+  }
+
+  return {
+    route,
+    status: "skipped",
+    reason: "dynamic",
+    ...(path !== route ? { path } : {}),
+  };
+}
+
 type PrerenderOptions = {
   /**
    * 'default' — prerender static/ISR routes; skip SSR routes
@@ -950,40 +973,57 @@ export async function prerenderPages({
           );
           const htmlFullPath = path.join(outDir, htmlOutputPath);
 
-          if (response.status >= 300 && response.status < 400) {
-            // getStaticProps returned a redirect — emit a meta-refresh HTML page
-            // so the static export can represent the redirect without a server.
-            const dest = response.headers.get("location") ?? "/";
-            const escapedDest = dest
-              .replace(/&/g, "&amp;")
-              .replace(/"/g, "&quot;")
-              .replace(/</g, "&lt;")
-              .replace(/>/g, "&gt;");
-            const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0;url=${escapedDest}" /></head><body></body></html>`;
-            fs.mkdirSync(path.dirname(htmlFullPath), { recursive: true });
-            fs.writeFileSync(htmlFullPath, html, "utf-8");
-            outputFiles.push(htmlOutputPath);
+          const isRedirectResponse = response.status >= 300 && response.status < 400;
+          const isDynamicResponse =
+            (response.ok || isRedirectResponse) &&
+            response.headers.get(VINEXT_PRERENDER_SHARED_CACHE_BYPASS_HEADER) === "1";
+          if (isDynamicResponse) {
+            await response.body?.cancel();
+            result = nonCacheablePagesResult(mode, route.pattern, urlPath);
+          } else if (!isRedirectResponse && !response.ok) {
+            const fatal = response.headers.get(VINEXT_PRERENDER_RENDER_ERROR_HEADER) === "1";
+            await response.body?.cancel();
+            const renderError = new Error(`renderPage returned ${response.status} for ${urlPath}`);
+            result = {
+              route: route.pattern,
+              status: "error",
+              error: config.enablePrerenderSourceMaps
+                ? getErrorMessageWithStack(renderError)
+                : renderError.message,
+              ...(fatal ? { fatal: true as const } : {}),
+            };
           } else {
-            if (!response.ok) {
-              throw new Error(`renderPage returned ${response.status} for ${urlPath}`);
+            if (isRedirectResponse) {
+              // getStaticProps returned a redirect — emit a meta-refresh HTML page
+              // so the static export can represent the redirect without a server.
+              const dest = response.headers.get("location") ?? "/";
+              const escapedDest = dest
+                .replace(/&/g, "&amp;")
+                .replace(/"/g, "&quot;")
+                .replace(/</g, "&lt;")
+                .replace(/>/g, "&gt;");
+              const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0;url=${escapedDest}" /></head><body></body></html>`;
+              fs.mkdirSync(path.dirname(htmlFullPath), { recursive: true });
+              fs.writeFileSync(htmlFullPath, html, "utf-8");
+              outputFiles.push(htmlOutputPath);
+            } else {
+              const html = await response.text();
+              fs.mkdirSync(path.dirname(htmlFullPath), { recursive: true });
+              fs.writeFileSync(htmlFullPath, html, "utf-8");
+              outputFiles.push(htmlOutputPath);
             }
-            const html = await response.text();
-            fs.mkdirSync(path.dirname(htmlFullPath), { recursive: true });
-            fs.writeFileSync(htmlFullPath, html, "utf-8");
-            outputFiles.push(htmlOutputPath);
+            result = {
+              route: route.pattern,
+              status: "rendered",
+              outputFiles,
+              revalidate,
+              // Pages Router cache metadata comes only from getStaticProps.revalidate;
+              // Next.js applies expireTime as the fallback when no route expire exists.
+              ...(typeof revalidate === "number" ? { expire: config.expireTime } : {}),
+              router: "pages",
+              ...(urlPath !== route.pattern ? { path: urlPath } : {}),
+            };
           }
-
-          result = {
-            route: route.pattern,
-            status: "rendered",
-            outputFiles,
-            revalidate,
-            // Pages Router cache metadata comes only from getStaticProps.revalidate;
-            // Next.js applies expireTime as the fallback when no route expire exists.
-            ...(typeof revalidate === "number" ? { expire: config.expireTime } : {}),
-            router: "pages",
-            ...(urlPath !== route.pattern ? { path: urlPath } : {}),
-          };
         } catch (e) {
           renderPool?.recordRenderError(e);
           const err = e as Error;
@@ -1016,15 +1056,32 @@ export async function prerenderPages({
       try {
         const notFoundRes = await renderPage(hasCustom404 ? "/404" : NOT_FOUND_SENTINEL_PATH);
         const contentType = notFoundRes.headers.get("content-type") ?? "";
-        if (notFoundRes.status === 404 && contentType.includes("text/html")) {
-          const html404 = await notFoundRes.text();
+        if (!notFoundRes.ok && notFoundRes.status !== 404) {
+          const fatal = notFoundRes.headers.get(VINEXT_PRERENDER_RENDER_ERROR_HEADER) === "1";
+          await notFoundRes.body?.cancel();
+          const renderError = new Error(`renderPage returned ${notFoundRes.status} for /404`);
           results.push({
             route: "/404",
-            status: "rendered",
-            outputFiles: emitStatic404Files(outDir, html404, config.trailingSlash),
-            revalidate: false,
-            router: "pages",
+            status: "error",
+            error: config.enablePrerenderSourceMaps
+              ? getErrorMessageWithStack(renderError)
+              : renderError.message,
+            ...(fatal ? { fatal: true as const } : {}),
           });
+        } else if (notFoundRes.status === 404 && contentType.includes("text/html")) {
+          if (notFoundRes.headers.get(VINEXT_PRERENDER_SHARED_CACHE_BYPASS_HEADER) === "1") {
+            await notFoundRes.body?.cancel();
+            results.push(nonCacheablePagesResult(mode, "/404"));
+          } else {
+            const html404 = await notFoundRes.text();
+            results.push({
+              route: "/404",
+              status: "rendered",
+              outputFiles: emitStatic404Files(outDir, html404, config.trailingSlash),
+              revalidate: false,
+              router: "pages",
+            });
+          }
         }
       } catch (e) {
         // No custom 404. When the render-worker pool is active, a transport

diff --git a/packages/vinext/src/server/app-prerender-endpoints.ts b/packages/vinext/src/server/app-prerender-endpoints.ts
@@ -5,6 +5,10 @@ import {
   VINEXT_PRERENDER_STATIC_PARAMS_PATH,
 } from "./headers.js";
 import { notFoundResponse } from "./http-error-responses.js";
+import {
+  assertPagesDataExportCompatibility,
+  type PagesDataExportModule,
+} from "./pages-data-export-compatibility.js";
 import type { RootParams } from "vinext/shims/root-params";
 
 type GenerateStaticParams = (args: { params: RootParams }) => unknown;
@@ -14,7 +18,7 @@ export type AppPrerenderRootParamNamesMap = Record<string, readonly string[] | u
 
 type AppPrerenderPageRoute = {
   pattern: string;
-  module?: {
+  module?: PagesDataExportModule & {
     getStaticPaths?: (opts: { locales: string[]; defaultLocale: string }) => unknown;
   };
 };
@@ -116,6 +120,9 @@ async function handlePagesStaticPathsEndpoint(
   try {
     const pageRoutes = await options.loadPagesRoutes?.();
     const route = findPageRoute(pageRoutes, pattern);
+    if (route?.module) {
+      assertPagesDataExportCompatibility(route.module, pattern);
+    }
     const getStaticPaths = route?.module?.getStaticPaths;
     if (typeof getStaticPaths !== "function") {
       return jsonNullResponse();

diff --git a/packages/vinext/src/server/dev-server.ts b/packages/vinext/src/server/dev-server.ts
@@ -61,6 +61,7 @@ import {
   type PagesRedirectResult,
   type PagesStaticPathsEntry,
 } from "./pages-page-data.js";
+import { assertPagesDataExportCompatibility } from "./pages-data-export-compatibility.js";
 import { sanitizeDestination } from "../config/config-matchers.js";
 import { collectPagesDevInitialStylesheetHeadHTML } from "./pages-dev-stylesheets.js";
 import { createPagesDevModuleUrl } from "./pages-dev-module-url.js";
@@ -937,6 +938,10 @@ export function createSSRHandler(
         // and `useRouter().isFallback === true`, matching Next.js render.tsx.
         let isFallbackRender = false;
 
+        if (typeof pageModule.getStaticProps === "function") {
+          assertPagesDataExportCompatibility(pageModule, patternToNextFormat(route.pattern));
+        }
+
         // Handle getStaticPaths for dynamic routes: validate the path,
         // respect `fallback: false` (return 404 for unlisted paths), and
         // render the loading shell for unlisted paths under `fallback: true`.
@@ -1215,6 +1220,7 @@ export function createSSRHandler(
         const scriptNonce = getScriptNonceFromNodeHeaderSources(req.headers, responseHeaders);
 
         if (typeof pageModule.getStaticProps === "function" && !isFallbackRender) {
+          const routePattern = patternToNextFormat(route.pattern);
           // An authenticated res.revalidate() request executes GSP once with the
           // on-demand reason, but Pages response entries are never read or
           // written in development. Ordinary requests independently rerun GSP
@@ -1258,7 +1264,6 @@ export function createSSRHandler(
           }
 
           const result = await pageModule.getStaticProps(context);
-          const routePattern = patternToNextFormat(route.pattern);
           assertPages404DoesNotReturnNotFound(routePattern, result);
           if (result) {
             staticPropsRevalidateSeconds = resolvePagesRevalidateSeconds(result, routePattern);

diff --git a/packages/vinext/src/server/headers.ts b/packages/vinext/src/server/headers.ts
@@ -99,6 +99,9 @@ export const VINEXT_PRERENDER_CACHE_LIFE_HEADER = "x-vinext-prerender-cache-life
 /** Marks a local prerender-server 500 that originated from a thrown render error. */
 export const VINEXT_PRERENDER_RENDER_ERROR_HEADER = "x-vinext-prerender-render-error";
 
+/** Marks a Pages prerender response whose request-derived App props prohibit reuse. */
+export const VINEXT_PRERENDER_SHARED_CACHE_BYPASS_HEADER = "x-vinext-prerender-shared-cache-bypass";
+
 /** Internal marker persisted only inside metadata-route APP_ROUTE cache values. */
 export const VINEXT_METADATA_ROUTE_CACHE_HEADER = "x-vinext-metadata-route-cache";
 

diff --git a/packages/vinext/src/server/pages-data-export-compatibility.ts b/packages/vinext/src/server/pages-data-export-compatibility.ts
@@ -0,0 +1,35 @@
+import { hasPagesGetInitialProps } from "./pages-get-initial-props.js";
+import { VINEXT_PRERENDER_SHARED_CACHE_BYPASS_HEADER } from "./headers.js";
+
+const SSG_GET_INITIAL_PROPS_CONFLICT =
+  "You can not use getInitialProps with getStaticProps. To use SSG, please remove your getInitialProps";
+
+export type PagesDataExportModule = {
+  default?: unknown;
+  getStaticProps?: unknown;
+};
+
+export class PagesDataExportCompatibilityError extends Error {
+  override name = "PagesDataExportCompatibilityError";
+}
+
+export function markPagesPrerenderSharedCacheBypass(headers: Headers): void {
+  if (process.env.VINEXT_PRERENDER === "1") {
+    headers.set(VINEXT_PRERENDER_SHARED_CACHE_BYPASS_HEADER, "1");
+  }
+}
+
+/** Reject Pages data-export combinations that Next.js does not allow. */
+export function assertPagesDataExportCompatibility(
+  pageModule: PagesDataExportModule,
+  routePattern: string,
+): void {
+  if (
+    typeof pageModule.getStaticProps === "function" &&
+    hasPagesGetInitialProps(pageModule.default)
+  ) {
+    throw new PagesDataExportCompatibilityError(
+      `${SSG_GET_INITIAL_PROPS_CONFLICT} ${routePattern}`,
+    );
+  }
+}