vinext 0.0.30 → 0.0.31

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

@@ -1,31 +1,33 @@
-/**
- * App Router RSC entry generator.
- *
- * Generates the virtual RSC entry module for the App Router.
- * The RSC entry does route matching and renders the component tree,
- * then delegates to the SSR entry for HTML generation.
- *
- * Previously housed in server/app-dev-server.ts.
- */
+import { isProxyFile } from "../server/middleware.js";
+import { generateMiddlewareMatcherCode, generateNormalizePathCode, generateRouteMatchNormalizationCode, generateSafeRegExpCode } from "../server/middleware-codegen.js";
+import { generateDevOriginCheckCode } from "../server/dev-origin-check.js";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
-import { generateDevOriginCheckCode } from "../server/dev-origin-check.js";
-import { generateMiddlewareMatcherCode, generateNormalizePathCode, generateSafeRegExpCode, generateRouteMatchNormalizationCode, } from "../server/middleware-codegen.js";
-import { isProxyFile } from "../server/middleware.js";
-// Pre-computed absolute paths for generated-code imports. The virtual RSC
-// entry can't use relative imports (it has no real file location), so we
-// resolve these at code-generation time and embed them as absolute paths.
+//#region src/entries/app-rsc-entry.ts
+/**
+* App Router RSC entry generator.
+*
+* Generates the virtual RSC entry module for the App Router.
+* The RSC entry does route matching and renders the component tree,
+* then delegates to the SSR entry for HTML generation.
+*
+* Previously housed in server/app-dev-server.ts.
+*/
 const configMatchersPath = fileURLToPath(new URL("../config/config-matchers.js", import.meta.url)).replace(/\\/g, "/");
 const requestPipelinePath = fileURLToPath(new URL("../server/request-pipeline.js", import.meta.url)).replace(/\\/g, "/");
 const requestContextShimPath = fileURLToPath(new URL("../shims/request-context.js", import.meta.url)).replace(/\\/g, "/");
 const routeTriePath = fileURLToPath(new URL("../routing/route-trie.js", import.meta.url)).replace(/\\/g, "/");
-// Canonical order of HTTP method handlers supported by route.ts modules.
-const ROUTE_HANDLER_HTTP_METHODS = ["GET", "HEAD", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
-// Runtime helpers injected into the generated RSC entry so OPTIONS/Allow handling
-// logic stays alongside the route handler pipeline.
-const routeHandlerHelperCode = String.raw `
+const routeHandlerHelperCode = String.raw`
 // Duplicated from the build-time constant above via JSON.stringify.
-const ROUTE_HANDLER_HTTP_METHODS = ${JSON.stringify(ROUTE_HANDLER_HTTP_METHODS)};
+const ROUTE_HANDLER_HTTP_METHODS = ${JSON.stringify([
+	"GET",
+	"HEAD",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"OPTIONS"
+])};
 
 function collectRouteHandlerMethods(handler) {
   const methods = ROUTE_HANDLER_HTTP_METHODS.filter((method) => typeof handler[method] === "function");
@@ -42,96 +44,74 @@ function buildRouteHandlerAllowHeader(exportedMethods) {
 }
 `;
 /**
- * Generate the virtual RSC entry module.
- *
- * This runs in the `rsc` Vite environment (react-server condition).
- * It matches the incoming request URL to an app route, builds the
- * nested layout + page tree, and renders it to an RSC stream.
- */
-export function generateRscEntry(appDir, routes, middlewarePath, metadataRoutes, globalErrorPath, basePath, trailingSlash, config, instrumentationPath) {
-    const bp = basePath ?? "";
-    const ts = trailingSlash ?? false;
-    const redirects = config?.redirects ?? [];
-    const rewrites = config?.rewrites ?? { beforeFiles: [], afterFiles: [], fallback: [] };
-    const headers = config?.headers ?? [];
-    const allowedOrigins = config?.allowedOrigins ?? [];
-    const bodySizeLimit = config?.bodySizeLimit ?? 1 * 1024 * 1024;
-    const i18nConfig = config?.i18n ?? null;
-    // Build import map for all page and layout files
-    const imports = [];
-    const importMap = new Map();
-    let importIdx = 0;
-    function getImportVar(filePath) {
-        if (importMap.has(filePath))
-            return importMap.get(filePath);
-        const varName = `mod_${importIdx++}`;
-        const absPath = filePath.replace(/\\/g, "/");
-        imports.push(`import * as ${varName} from ${JSON.stringify(absPath)};`);
-        importMap.set(filePath, varName);
-        return varName;
-    }
-    // Pre-register all modules
-    for (const route of routes) {
-        if (route.pagePath)
-            getImportVar(route.pagePath);
-        if (route.routePath)
-            getImportVar(route.routePath);
-        for (const layout of route.layouts)
-            getImportVar(layout);
-        for (const tmpl of route.templates)
-            getImportVar(tmpl);
-        if (route.loadingPath)
-            getImportVar(route.loadingPath);
-        if (route.errorPath)
-            getImportVar(route.errorPath);
-        if (route.layoutErrorPaths)
-            for (const ep of route.layoutErrorPaths) {
-                if (ep)
-                    getImportVar(ep);
-            }
-        if (route.notFoundPath)
-            getImportVar(route.notFoundPath);
-        for (const nfp of route.notFoundPaths || []) {
-            if (nfp)
-                getImportVar(nfp);
-        }
-        if (route.forbiddenPath)
-            getImportVar(route.forbiddenPath);
-        if (route.unauthorizedPath)
-            getImportVar(route.unauthorizedPath);
-        // Register parallel slot modules
-        for (const slot of route.parallelSlots) {
-            if (slot.pagePath)
-                getImportVar(slot.pagePath);
-            if (slot.defaultPath)
-                getImportVar(slot.defaultPath);
-            if (slot.layoutPath)
-                getImportVar(slot.layoutPath);
-            if (slot.loadingPath)
-                getImportVar(slot.loadingPath);
-            if (slot.errorPath)
-                getImportVar(slot.errorPath);
-            // Register intercepting route page modules
-            for (const ir of slot.interceptingRoutes) {
-                getImportVar(ir.pagePath);
-            }
-        }
-    }
-    // Build route table as serialized JS
-    const routeEntries = routes.map((route) => {
-        const layoutVars = route.layouts.map((l) => getImportVar(l));
-        const templateVars = route.templates.map((t) => getImportVar(t));
-        const notFoundVars = (route.notFoundPaths || []).map((nf) => (nf ? getImportVar(nf) : "null"));
-        const slotEntries = route.parallelSlots.map((slot) => {
-            const interceptEntries = slot.interceptingRoutes.map((ir) => {
-                return `        {
+* Generate the virtual RSC entry module.
+*
+* This runs in the `rsc` Vite environment (react-server condition).
+* It matches the incoming request URL to an app route, builds the
+* nested layout + page tree, and renders it to an RSC stream.
+*/
+function generateRscEntry(appDir, routes, middlewarePath, metadataRoutes, globalErrorPath, basePath, trailingSlash, config, instrumentationPath) {
+	const bp = basePath ?? "";
+	const ts = trailingSlash ?? false;
+	const redirects = config?.redirects ?? [];
+	const rewrites = config?.rewrites ?? {
+		beforeFiles: [],
+		afterFiles: [],
+		fallback: []
+	};
+	const headers = config?.headers ?? [];
+	const allowedOrigins = config?.allowedOrigins ?? [];
+	const bodySizeLimit = config?.bodySizeLimit ?? 1 * 1024 * 1024;
+	const i18nConfig = config?.i18n ?? null;
+	const hasPagesDir = config?.hasPagesDir ?? false;
+	const imports = [];
+	const importMap = /* @__PURE__ */ new Map();
+	let importIdx = 0;
+	function getImportVar(filePath) {
+		if (importMap.has(filePath)) return importMap.get(filePath);
+		const varName = `mod_${importIdx++}`;
+		const absPath = filePath.replace(/\\/g, "/");
+		imports.push(`import * as ${varName} from ${JSON.stringify(absPath)};`);
+		importMap.set(filePath, varName);
+		return varName;
+	}
+	for (const route of routes) {
+		if (route.pagePath) getImportVar(route.pagePath);
+		if (route.routePath) getImportVar(route.routePath);
+		for (const layout of route.layouts) getImportVar(layout);
+		for (const tmpl of route.templates) getImportVar(tmpl);
+		if (route.loadingPath) getImportVar(route.loadingPath);
+		if (route.errorPath) getImportVar(route.errorPath);
+		if (route.layoutErrorPaths) {
+			for (const ep of route.layoutErrorPaths) if (ep) getImportVar(ep);
+		}
+		if (route.notFoundPath) getImportVar(route.notFoundPath);
+		for (const nfp of route.notFoundPaths || []) if (nfp) getImportVar(nfp);
+		if (route.forbiddenPath) getImportVar(route.forbiddenPath);
+		if (route.unauthorizedPath) getImportVar(route.unauthorizedPath);
+		for (const slot of route.parallelSlots) {
+			if (slot.pagePath) getImportVar(slot.pagePath);
+			if (slot.defaultPath) getImportVar(slot.defaultPath);
+			if (slot.layoutPath) getImportVar(slot.layoutPath);
+			if (slot.loadingPath) getImportVar(slot.loadingPath);
+			if (slot.errorPath) getImportVar(slot.errorPath);
+			for (const ir of slot.interceptingRoutes) getImportVar(ir.pagePath);
+		}
+	}
+	const routeEntries = routes.map((route) => {
+		const layoutVars = route.layouts.map((l) => getImportVar(l));
+		const templateVars = route.templates.map((t) => getImportVar(t));
+		const notFoundVars = (route.notFoundPaths || []).map((nf) => nf ? getImportVar(nf) : "null");
+		const slotEntries = route.parallelSlots.map((slot) => {
+			const interceptEntries = slot.interceptingRoutes.map((ir) => {
+				return `        {
           convention: ${JSON.stringify(ir.convention)},
           targetPattern: ${JSON.stringify(ir.targetPattern)},
           page: ${getImportVar(ir.pagePath)},
           params: ${JSON.stringify(ir.params)},
         }`;
-            });
-            return `      ${JSON.stringify(slot.name)}: {
+			});
+			return `      ${JSON.stringify(slot.name)}: {
         page: ${slot.pagePath ? getImportVar(slot.pagePath) : "null"},
         default: ${slot.defaultPath ? getImportVar(slot.defaultPath) : "null"},
         layout: ${slot.layoutPath ? getImportVar(slot.layoutPath) : "null"},
@@ -142,9 +122,9 @@ export function generateRscEntry(appDir, routes, middlewarePath, metadataRoutes,
 ${interceptEntries.join(",\n")}
         ],
       }`;
-        });
-        const layoutErrorVars = (route.layoutErrorPaths || []).map((ep) => ep ? getImportVar(ep) : "null");
-        return `  {
+		});
+		const layoutErrorVars = (route.layoutErrorPaths || []).map((ep) => ep ? getImportVar(ep) : "null");
+		return `  {
     pattern: ${JSON.stringify(route.pattern)},
     patternParts: ${JSON.stringify(route.patternParts)},
     isDynamic: ${route.isDynamic},
@@ -166,86 +146,80 @@ ${slotEntries.join(",\n")}
     forbidden: ${route.forbiddenPath ? getImportVar(route.forbiddenPath) : "null"},
     unauthorized: ${route.unauthorizedPath ? getImportVar(route.unauthorizedPath) : "null"},
   }`;
-    });
-    // Find root not-found/forbidden/unauthorized pages and root layouts for global error handling
-    const rootRoute = routes.find((r) => r.pattern === "/");
-    const rootNotFoundVar = rootRoute?.notFoundPath ? getImportVar(rootRoute.notFoundPath) : null;
-    const rootForbiddenVar = rootRoute?.forbiddenPath ? getImportVar(rootRoute.forbiddenPath) : null;
-    const rootUnauthorizedVar = rootRoute?.unauthorizedPath
-        ? getImportVar(rootRoute.unauthorizedPath)
-        : null;
-    const rootLayoutVars = rootRoute ? rootRoute.layouts.map((l) => getImportVar(l)) : [];
-    // Global error boundary (app/global-error.tsx)
-    const globalErrorVar = globalErrorPath ? getImportVar(globalErrorPath) : null;
-    // Build metadata route handling
-    const effectiveMetaRoutes = metadataRoutes ?? [];
-    const dynamicMetaRoutes = effectiveMetaRoutes.filter((r) => r.isDynamic);
-    // Import dynamic metadata modules
-    for (const mr of dynamicMetaRoutes) {
-        getImportVar(mr.filePath);
-    }
-    // Build metadata route table
-    // For static metadata files, read the file content at code-generation time
-    // and embed it as base64. This ensures static metadata files work on runtimes
-    // without filesystem access (e.g., Cloudflare Workers).
-    //
-    // For metadata routes in dynamic segments (e.g., /blog/[slug]/opengraph-image),
-    // generate patternParts so the runtime can use matchPattern() instead of strict
-    // equality — the same matching used for intercept routes.
-    const metaRouteEntries = effectiveMetaRoutes.map((mr) => {
-        // Convert dynamic segments in servedUrl to matchPattern format.
-        // Keep in sync with routing/app-router.ts patternParts generation.
-        //   [param]       → :param
-        //   [...param]    → :param+
-        //   [[...param]]  → :param*
-        const patternParts = mr.isDynamic && mr.servedUrl.includes("[")
-            ? JSON.stringify(mr.servedUrl
-                .split("/")
-                .filter(Boolean)
-                .map((seg) => {
-                if (seg.startsWith("[[...") && seg.endsWith("]]"))
-                    return ":" + seg.slice(5, -2) + "*";
-                if (seg.startsWith("[...") && seg.endsWith("]"))
-                    return ":" + seg.slice(4, -1) + "+";
-                if (seg.startsWith("[") && seg.endsWith("]"))
-                    return ":" + seg.slice(1, -1);
-                return seg;
-            }))
-            : null;
-        if (mr.isDynamic) {
-            return `  {
+	});
+	const rootRoute = routes.find((r) => r.pattern === "/");
+	const rootNotFoundVar = rootRoute?.notFoundPath ? getImportVar(rootRoute.notFoundPath) : null;
+	const rootForbiddenVar = rootRoute?.forbiddenPath ? getImportVar(rootRoute.forbiddenPath) : null;
+	const rootUnauthorizedVar = rootRoute?.unauthorizedPath ? getImportVar(rootRoute.unauthorizedPath) : null;
+	const rootLayoutVars = rootRoute ? rootRoute.layouts.map((l) => getImportVar(l)) : [];
+	const globalErrorVar = globalErrorPath ? getImportVar(globalErrorPath) : null;
+	const effectiveMetaRoutes = metadataRoutes ?? [];
+	const dynamicMetaRoutes = effectiveMetaRoutes.filter((r) => r.isDynamic);
+	for (const mr of dynamicMetaRoutes) getImportVar(mr.filePath);
+	const metaRouteEntries = effectiveMetaRoutes.map((mr) => {
+		const patternParts = mr.isDynamic && mr.servedUrl.includes("[") ? JSON.stringify(mr.servedUrl.split("/").filter(Boolean).map((seg) => {
+			if (seg.startsWith("[[...") && seg.endsWith("]]")) return ":" + seg.slice(5, -2) + "*";
+			if (seg.startsWith("[...") && seg.endsWith("]")) return ":" + seg.slice(4, -1) + "+";
+			if (seg.startsWith("[") && seg.endsWith("]")) return ":" + seg.slice(1, -1);
+			return seg;
+		})) : null;
+		if (mr.isDynamic) return `  {
     type: ${JSON.stringify(mr.type)},
     isDynamic: true,
     servedUrl: ${JSON.stringify(mr.servedUrl)},
     contentType: ${JSON.stringify(mr.contentType)},
     module: ${getImportVar(mr.filePath)},${patternParts ? `\n    patternParts: ${patternParts},` : ""}
   }`;
-        }
-        // Static: read file and embed as base64
-        let fileDataBase64 = "";
-        try {
-            const buf = fs.readFileSync(mr.filePath);
-            fileDataBase64 = buf.toString("base64");
-        }
-        catch {
-            // File unreadable — will serve empty response at runtime
-        }
-        return `  {
+		let fileDataBase64 = "";
+		try {
+			fileDataBase64 = fs.readFileSync(mr.filePath).toString("base64");
+		} catch {}
+		return `  {
     type: ${JSON.stringify(mr.type)},
     isDynamic: false,
     servedUrl: ${JSON.stringify(mr.servedUrl)},
     contentType: ${JSON.stringify(mr.contentType)},
     fileDataBase64: ${JSON.stringify(fileDataBase64)},
   }`;
-    });
-    return `
+	});
+	return `
 import {
-  renderToReadableStream,
+  renderToReadableStream as _renderToReadableStream,
   decodeReply,
   loadServerAction,
   createTemporaryReferenceSet,
 } from "@vitejs/plugin-rsc/rsc";
 import { AsyncLocalStorage } from "node:async_hooks";
+
+// React Flight emits HL hints with "stylesheet" for CSS, but the HTML spec
+// requires "style" for <link rel="preload">. Fix at the source so every
+// consumer (SSR embed, client-side navigation, server actions) gets clean data.
+//
+// Flight lines are newline-delimited, so we buffer partial lines across chunks
+// to guarantee the regex never sees a split hint.
+function renderToReadableStream(model, options) {
+  const _hlFixRe = /(\\d+:HL\\[.*?),"stylesheet"(\\]|,)/g;
+  const stream = _renderToReadableStream(model, options);
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let carry = "";
+  return stream.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      const text = carry + decoder.decode(chunk, { stream: true });
+      const lastNl = text.lastIndexOf("\\n");
+      if (lastNl === -1) {
+        carry = text;
+        return;
+      }
+      carry = text.slice(lastNl + 1);
+      controller.enqueue(encoder.encode(text.slice(0, lastNl + 1).replace(_hlFixRe, '$1,"style"$2')));
+    },
+    flush(controller) {
+      const text = carry + decoder.decode();
+      if (text) controller.enqueue(encoder.encode(text.replace(_hlFixRe, '$1,"style"$2')));
+    }
+  }));
+}
 import { createElement, Suspense, Fragment } from "react";
 import { setNavigationContext as _setNavigationContextOrig, getNavigationContext as _getNavigationContext } from "next/navigation";
 import { setHeadersContext, headersContextFromRequest, getDraftModeCookieHeader, getAndClearPendingCookies, consumeDynamicUsage, markDynamicUsage, applyMiddlewareRequestHeaders, getHeadersContext, setHeadersAccessPhase } from "next/headers";
@@ -270,6 +244,7 @@ import { getSSRFontLinks as _getSSRFontLinks, getSSRFontStyles as _getSSRFontSty
 import { getSSRFontStyles as _getSSRFontStylesLocal, getSSRFontPreloads as _getSSRFontPreloadsLocal } from "next/font/local";
 function _getSSRFontStyles() { return [..._getSSRFontStylesGoogle(), ..._getSSRFontStylesLocal()]; }
 function _getSSRFontPreloads() { return [..._getSSRFontPreloadsGoogle(), ..._getSSRFontPreloadsLocal()]; }
+${hasPagesDir ? `// Note: pageRoutes loaded lazily via SSR env in /__vinext/prerender/pages-static-paths handler` : ""}
 ${routeHandlerHelperCode}
 
 // ALS used to suppress the expected "Invalid hook call" dev warning when
@@ -316,6 +291,18 @@ async function __isrSet(key, data, revalidateSeconds, tags) {
 }
 function __pageCacheTags(pathname, extraTags) {
   const tags = [pathname, "_N_T_" + pathname];
+  // Layout hierarchy tags — matches Next.js getDerivedTags.
+  tags.push("_N_T_/layout");
+  const segments = pathname.split("/");
+  let built = "";
+  for (let i = 1; i < segments.length; i++) {
+    if (segments[i]) {
+      built += "/" + segments[i];
+      tags.push("_N_T_" + built + "/layout");
+    }
+  }
+  // Leaf page tag — revalidatePath(path, "page") targets this.
+  tags.push("_N_T_" + built + "/page");
   if (Array.isArray(extraTags)) {
     for (const tag of extraTags) {
       if (!tags.includes(tag)) tags.push(tag);
@@ -380,6 +367,7 @@ function __isrCacheKey(pathname, suffix) {
 }
 function __isrHtmlKey(pathname) { return __isrCacheKey(pathname, "html"); }
 function __isrRscKey(pathname) { return __isrCacheKey(pathname, "rsc"); }
+function __isrRouteKey(pathname) { return __isrCacheKey(pathname, "route"); }
 // Verbose cache logging — opt in with NEXT_PRIVATE_DEBUG_CACHE=1.
 // Matches the env var Next.js uses for its own cache debug output so operators
 // have a single knob for all cache tracing.
@@ -562,8 +550,7 @@ function createRscOnErrorHandler(request, pathname, routePath) {
 
 ${imports.join("\n")}
 
-${instrumentationPath
-        ? `// Run instrumentation register() exactly once, lazily on the first request.
+${instrumentationPath ? `// Run instrumentation register() exactly once, lazily on the first request.
 // Previously this was a top-level await, which blocked the entire module graph
 // from finishing initialization until register() resolved — adding that latency
 // to every cold start. Moving it here preserves the "runs before any request is
@@ -574,6 +561,7 @@ ${instrumentationPath
 let __instrumentationInitialized = false;
 let __instrumentationInitPromise = null;
 async function __ensureInstrumentation() {
+  if (process.env.VINEXT_PRERENDER === "1") return;
   if (__instrumentationInitialized) return;
   if (__instrumentationInitPromise) return __instrumentationInitPromise;
   __instrumentationInitPromise = (async () => {
@@ -592,8 +580,7 @@ async function __ensureInstrumentation() {
     __instrumentationInitialized = true;
   })();
   return __instrumentationInitPromise;
-}`
-        : ""}
+}` : ""}
 
 const routes = [
 ${routeEntries.join(",\n")}
@@ -690,8 +677,7 @@ async function renderHTTPAccessFallbackPage(route, statusCode, isRscRequest, req
         element = createElement(LayoutSegmentProvider, { childSegments: _cs }, element);
       }
     }
-    ${globalErrorVar
-        ? `
+    ${globalErrorVar ? `
     const _GlobalErrorComponent = ${globalErrorVar}.default;
     if (_GlobalErrorComponent) {
       element = createElement(ErrorBoundary, {
@@ -699,8 +685,7 @@ async function renderHTTPAccessFallbackPage(route, statusCode, isRscRequest, req
         children: element,
       });
     }
-    `
-        : ""}
+    ` : ""}
     const _pathname = new URL(request.url).pathname;
     const onRenderError = createRscOnErrorHandler(
       request,
@@ -780,14 +765,12 @@ async function renderErrorBoundaryPage(route, error, isRscRequest, request, matc
       }
     }
   }
-  ${globalErrorVar
-        ? `
+  ${globalErrorVar ? `
   if (!ErrorComponent) {
     ErrorComponent = ${globalErrorVar}?.default ?? null;
     _isGlobalError = !!ErrorComponent;
   }
-  `
-        : ""}
+  ` : ""}
   if (!ErrorComponent) return null;
 
   const rawError = error instanceof Error ? error : new Error(String(error));
@@ -825,8 +808,7 @@ async function renderErrorBoundaryPage(route, error, isRscRequest, request, matc
           element = createElement(LayoutSegmentProvider, { childSegments: _ecs }, element);
         }
       }
-      ${globalErrorVar
-        ? `
+      ${globalErrorVar ? `
       const _ErrGlobalComponent = ${globalErrorVar}.default;
       if (_ErrGlobalComponent) {
         element = createElement(ErrorBoundary, {
@@ -834,8 +816,7 @@ async function renderErrorBoundaryPage(route, error, isRscRequest, request, matc
           children: element,
         });
       }
-      `
-        : ""}
+      ` : ""}
     } else {
       // For HTML (full page load) responses, wrap with layouts only.
       const _errParamsHtml = matchedParams ?? route?.params ?? {};
@@ -1245,8 +1226,7 @@ async function buildPageElement(route, params, opts, searchParams) {
   // For HTML requests (initial page load), the ErrorBoundary catches during SSR
   // but produces double <html>/<body> (root layout + global-error). The request
   // handler detects this via the rscOnError flag and re-renders without layouts.
-  ${globalErrorVar
-        ? `
+  ${globalErrorVar ? `
   const GlobalErrorComponent = ${globalErrorVar}.default;
   if (GlobalErrorComponent) {
     element = createElement(ErrorBoundary, {
@@ -1254,8 +1234,7 @@ async function buildPageElement(route, params, opts, searchParams) {
       children: element,
     });
   }
-  `
-        : ""}
+  ` : ""}
 
   return element;
 }
@@ -1374,13 +1353,23 @@ async function __readFormDataWithLimit(request, maxBytes) {
   return new Response(combined, { headers: { "Content-Type": contentType } }).formData();
 }
 
+// Map from route pattern to generateStaticParams function.
+// Used by the prerender phase to enumerate dynamic route URLs without
+// loading route modules via the dev server.
+export const generateStaticParamsMap = {
+// TODO: layout-level generateStaticParams — this map only includes routes that
+// have a pagePath (leaf pages). Layout segments can also export generateStaticParams
+// to provide parent params for nested dynamic routes, but they don't have a pagePath
+// so they are excluded here. Supporting layout-level generateStaticParams requires
+// scanning layout.tsx files separately and including them in this map.
+${routes.filter((r) => r.isDynamic && r.pagePath).map((r) => `  ${JSON.stringify(r.pattern)}: ${getImportVar(r.pagePath)}?.generateStaticParams ?? null,`).join("\n")}
+};
+
 export default async function handler(request, ctx) {
-  ${instrumentationPath
-        ? `// Ensure instrumentation.register() has run before handling the first request.
+  ${instrumentationPath ? `// Ensure instrumentation.register() has run before handling the first request.
   // This is a no-op after the first call (guarded by __instrumentationInitialized).
   await __ensureInstrumentation();
-  `
-        : ""}
+  ` : ""}
   // Wrap the entire request in a single unified ALS scope for per-request
   // isolation. All state modules (headers, navigation, cache, fetch-cache,
   // execution-context) read from this store via isInsideUnifiedScope().
@@ -1457,12 +1446,79 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
   }
   let pathname = __normalizePath(decodedUrlPathname);
 
-  ${bp
-        ? `
+  ${bp ? `
   // Strip basePath prefix
   pathname = stripBasePath(pathname, __basePath);
-  `
-        : ""}
+  ` : ""}
+
+  // ── Prerender: static-params endpoint ────────────────────────────────
+  // Internal endpoint used by prerenderApp() during build to fetch
+  // generateStaticParams results via wrangler unstable_startWorker.
+  // Gated on VINEXT_PRERENDER=1 to prevent exposure in normal deployments.
+  // For Node builds, process.env.VINEXT_PRERENDER is set directly by the
+  // prerender orchestrator. For CF Workers builds, wrangler unstable_startWorker
+  // injects VINEXT_PRERENDER as a binding which Miniflare exposes via process.env
+  // in bundled workers. The /__vinext/ prefix ensures no user route ever conflicts.
+  if (pathname === "/__vinext/prerender/static-params") {
+    if (process.env.VINEXT_PRERENDER !== "1") {
+      return new Response("Not Found", { status: 404 });
+    }
+    const pattern = url.searchParams.get("pattern");
+    if (!pattern) return new Response("missing pattern", { status: 400 });
+    const fn = generateStaticParamsMap[pattern];
+    if (typeof fn !== "function") return new Response("null", { status: 200, headers: { "content-type": "application/json" } });
+    try {
+      const parentParams = url.searchParams.get("parentParams");
+      const raw = parentParams ? JSON.parse(parentParams) : {};
+      // Ensure params is a plain object — reject primitives, arrays, and null
+      // so user-authored generateStaticParams always receives { params: {} }
+      // rather than { params: 5 } or similar if input is malformed.
+      const params = (typeof raw === "object" && raw !== null && !Array.isArray(raw)) ? raw : {};
+      const result = await fn({ params });
+      return new Response(JSON.stringify(result), { status: 200, headers: { "content-type": "application/json" } });
+    } catch (e) {
+      return new Response(JSON.stringify({ error: String(e) }), { status: 500, headers: { "content-type": "application/json" } });
+    }
+  }
+
+  ${hasPagesDir ? `
+  // ── Prerender: pages-static-paths endpoint ───────────────────────────
+  // Internal endpoint used by prerenderPages() during a CF Workers hybrid
+  // build to call getStaticPaths() for dynamic Pages Router routes via
+  // wrangler unstable_startWorker. Returns JSON-serialised getStaticPaths result.
+  // Gated on VINEXT_PRERENDER=1 to prevent exposure in normal deployments.
+  // See static-params endpoint above for process.env vs CF vars notes.
+  //
+  // pageRoutes lives in the SSR environment (virtual:vinext-server-entry).
+  // We load it lazily via import.meta.viteRsc.loadModule — the same pattern
+  // used by handleSsr() elsewhere in this template. At build time, Vite's RSC
+  // plugin transforms this call into a bundled cross-environment import, so it
+  // works correctly in the CF Workers production bundle running in Miniflare.
+  if (pathname === "/__vinext/prerender/pages-static-paths") {
+    if (process.env.VINEXT_PRERENDER !== "1") {
+      return new Response("Not Found", { status: 404 });
+    }
+    const __gspPattern = url.searchParams.get("pattern");
+    if (!__gspPattern) return new Response("missing pattern", { status: 400 });
+    try {
+      const __gspSsrEntry = await import.meta.viteRsc.loadModule("ssr", "index");
+      const __pagesRoutes = __gspSsrEntry.pageRoutes;
+      const __gspRoute = Array.isArray(__pagesRoutes)
+        ? __pagesRoutes.find((r) => r.pattern === __gspPattern)
+        : undefined;
+      if (!__gspRoute || typeof __gspRoute.module?.getStaticPaths !== "function") {
+        return new Response("null", { status: 200, headers: { "content-type": "application/json" } });
+      }
+      const __localesParam = url.searchParams.get("locales");
+      const __locales = __localesParam ? JSON.parse(__localesParam) : [];
+      const __defaultLocale = url.searchParams.get("defaultLocale") ?? "";
+      const __gspResult = await __gspRoute.module.getStaticPaths({ locales: __locales, defaultLocale: __defaultLocale });
+      return new Response(JSON.stringify(__gspResult), { status: 200, headers: { "content-type": "application/json" } });
+    } catch (e) {
+      return new Response(JSON.stringify({ error: String(e) }), { status: 500, headers: { "content-type": "application/json" } });
+    }
+  }
+  ` : ""}
 
   // Trailing slash normalization (redirect to canonical form)
   const __tsRedirect = normalizeTrailingSlash(pathname, __basePath, __trailingSlash, url.search);
@@ -1497,8 +1553,48 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
   // _mwCtx (per-request container) so handler() can merge them into
   // every response path without module-level state that races on Workers.
 
-  ${middlewarePath
-        ? `
+  ${middlewarePath ? `
+  // In hybrid app+pages dev mode the connect handler already ran middleware
+  // and forwarded the results via x-vinext-mw-ctx. Reconstruct _mwCtx from
+  // the forwarded data instead of re-running the middleware function.
+  // Guarded by NODE_ENV because this header only exists in dev (the connect
+  // handler sets it). In production there is no connect handler, so an
+  // attacker-supplied header must not be trusted.
+  let __mwCtxApplied = false;
+  if (process.env.NODE_ENV !== "production") {
+    const __mwCtxHeader = request.headers.get("x-vinext-mw-ctx");
+    if (__mwCtxHeader) {
+      try {
+        const __mwCtxData = JSON.parse(__mwCtxHeader);
+        if (__mwCtxData.h && __mwCtxData.h.length > 0) {
+          // Note: h may include x-middleware-request-* internal headers so
+          // applyMiddlewareRequestHeaders() can unpack them below.
+          // processMiddlewareHeaders() strips them before any response.
+          _mwCtx.headers = new Headers();
+          for (const [key, value] of __mwCtxData.h) {
+            _mwCtx.headers.append(key, value);
+          }
+        }
+        if (__mwCtxData.s != null) {
+          _mwCtx.status = __mwCtxData.s;
+        }
+        // Apply forwarded middleware rewrite so routing uses the rewritten path.
+        // The RSC plugin constructs its Request from the original HTTP request,
+        // not from req.url, so the connect handler's req.url rewrite is invisible.
+        if (__mwCtxData.r) {
+          const __rewriteParsed = new URL(__mwCtxData.r, request.url);
+          cleanPathname = __rewriteParsed.pathname;
+          url.search = __rewriteParsed.search;
+        }
+        // Flag set after full context application — if any step fails (e.g. malformed
+        // rewrite URL), we fall back to re-running middleware as a safety net.
+        __mwCtxApplied = true;
+      } catch (e) {
+        console.error("[vinext] Failed to parse forwarded middleware context:", e);
+      }
+    }
+  }
+  if (!__mwCtxApplied) {
    // Run proxy/middleware if present and path matches.
    // Validate exports match the file type (proxy.ts vs middleware.ts), matching Next.js behavior.
    // https://github.com/vercel/next.js/blob/canary/test/e2e/app-dir/proxy-missing-export/proxy-missing-export.test.ts
@@ -1576,6 +1672,7 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
       return new Response("Internal Server Error", { status: 500 });
     }
   }
+  } // end of if (!__mwCtxApplied)
 
   // Unpack x-middleware-request-* headers into the request context so that
   // headers() returns the middleware-modified headers instead of the original
@@ -1586,8 +1683,7 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
     applyMiddlewareRequestHeaders(_mwCtx.headers);
     processMiddlewareHeaders(_mwCtx.headers);
   }
-  `
-        : ""}
+  ` : ""}
 
   // Build post-middleware request context for afterFiles/fallback rewrites.
   // These run after middleware in the App Router execution order and should
@@ -1897,6 +1993,28 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
   }
 
   if (!match) {
+    ${hasPagesDir ? `
+    // ── Pages Router fallback ────────────────────────────────────────────
+    // When a request doesn't match any App Router route, delegate to the
+    // Pages Router handler (available in the SSR environment). This covers
+    // both production request serving and prerender fetches from wrangler.
+    // RSC requests (.rsc suffix or Accept: text/x-component) cannot be
+    // handled by the Pages Router, so skip the delegation for those.
+    if (!isRscRequest) {
+      const __pagesEntry = await import.meta.viteRsc.loadModule("ssr", "index");
+      if (typeof __pagesEntry.renderPage === "function") {
+        const __pagesRes = await __pagesEntry.renderPage(request, decodeURIComponent(url.pathname) + (url.search || ""), {});
+        // Only return the Pages Router response if it matched a route
+        // (non-404). A 404 means the path isn't a Pages route either,
+        // so fall through to the App Router not-found page below.
+        if (__pagesRes.status !== 404) {
+          setHeadersContext(null);
+          setNavigationContext(null);
+          return __pagesRes;
+        }
+      }
+    }
+    ` : ""}
     // Render custom not-found page if available, otherwise plain 404
     const notFoundResponse = await renderNotFoundPage(null, isRscRequest, request);
     if (notFoundResponse) return notFoundResponse;
@@ -1918,7 +2036,7 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
   if (route.routeHandler) {
     const handler = route.routeHandler;
     const method = request.method.toUpperCase();
-    const revalidateSeconds = typeof handler.revalidate === "number" && handler.revalidate > 0 ? handler.revalidate : null;
+    const revalidateSeconds = typeof handler.revalidate === "number" && handler.revalidate > 0 && handler.revalidate !== Infinity ? handler.revalidate : null;
     if (typeof handler["default"] === "function" && process.env.NODE_ENV === "development") {
       console.error(
         "[vinext] Detected default export in route handler " + route.pattern + ". Export a named export for each HTTP method instead.",
@@ -1970,11 +2088,91 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
       isAutoHead = true;
     }
 
+    // ISR cache read for route handlers (production only).
+    // Only GET/HEAD (auto-HEAD) with finite revalidate > 0 are ISR-eligible.
+    // This runs before handler execution so a cache HIT skips the handler entirely.
+    if (
+      process.env.NODE_ENV === "production" &&
+      revalidateSeconds !== null &&
+      handler.dynamic !== "force-dynamic" &&
+      (method === "GET" || isAutoHead) &&
+      typeof handlerFn === "function"
+    ) {
+      const __routeKey = __isrRouteKey(cleanPathname);
+      try {
+        const __cached = await __isrGet(__routeKey);
+        if (__cached && !__cached.isStale && __cached.value.value && __cached.value.value.kind === "APP_ROUTE") {
+          // HIT — return cached response immediately
+          const __cv = __cached.value.value;
+          __isrDebug?.("HIT (route)", cleanPathname);
+          setHeadersContext(null);
+          setNavigationContext(null);
+          const __hitHeaders = Object.assign({}, __cv.headers || {});
+          __hitHeaders["X-Vinext-Cache"] = "HIT";
+          __hitHeaders["Cache-Control"] = "s-maxage=" + revalidateSeconds + ", stale-while-revalidate";
+          if (isAutoHead) {
+            return attachRouteHandlerMiddlewareContext(new Response(null, { status: __cv.status, headers: __hitHeaders }));
+          }
+          return attachRouteHandlerMiddlewareContext(new Response(__cv.body, { status: __cv.status, headers: __hitHeaders }));
+        }
+        if (__cached && __cached.isStale && __cached.value.value && __cached.value.value.kind === "APP_ROUTE") {
+          // STALE — serve stale response, trigger background regeneration
+          const __sv = __cached.value.value;
+          const __revalSecs = revalidateSeconds;
+          const __revalHandlerFn = handlerFn;
+          const __revalParams = params;
+          const __revalUrl = request.url;
+          const __revalSearchParams = new URLSearchParams(url.searchParams);
+          __triggerBackgroundRegeneration(__routeKey, async function() {
+            const __revalHeadCtx = { headers: new Headers(), cookies: new Map() };
+            const __revalUCtx = _createUnifiedCtx({
+              headersContext: __revalHeadCtx,
+              executionContext: _getRequestExecutionContext(),
+            });
+            await _runWithUnifiedCtx(__revalUCtx, async () => {
+              _ensureFetchPatch();
+              setNavigationContext({ pathname: cleanPathname, searchParams: __revalSearchParams, params: __revalParams });
+              const __syntheticReq = new Request(__revalUrl, { method: "GET" });
+              const __revalResponse = await __revalHandlerFn(__syntheticReq, { params: __revalParams });
+              const __regenDynamic = consumeDynamicUsage();
+              setNavigationContext(null);
+              if (__regenDynamic) {
+                __isrDebug?.("route regen skipped (dynamic usage)", cleanPathname);
+                return;
+              }
+              const __freshBody = await __revalResponse.arrayBuffer();
+              const __freshHeaders = {};
+              __revalResponse.headers.forEach(function(v, k) {
+                if (k !== "x-vinext-cache" && k !== "cache-control") __freshHeaders[k] = v;
+              });
+              const __routeTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
+              await __isrSet(__routeKey, { kind: "APP_ROUTE", body: __freshBody, status: __revalResponse.status, headers: __freshHeaders }, __revalSecs, __routeTags);
+              __isrDebug?.("route regen complete", __routeKey);
+            });
+          });
+          __isrDebug?.("STALE (route)", cleanPathname);
+          setHeadersContext(null);
+          setNavigationContext(null);
+          const __staleHeaders = Object.assign({}, __sv.headers || {});
+          __staleHeaders["X-Vinext-Cache"] = "STALE";
+          __staleHeaders["Cache-Control"] = "s-maxage=0, stale-while-revalidate";
+          if (isAutoHead) {
+            return attachRouteHandlerMiddlewareContext(new Response(null, { status: __sv.status, headers: __staleHeaders }));
+          }
+          return attachRouteHandlerMiddlewareContext(new Response(__sv.body, { status: __sv.status, headers: __staleHeaders }));
+        }
+      } catch (__routeCacheErr) {
+        // Cache read failure — fall through to normal handler execution
+        console.error("[vinext] ISR route cache read error:", __routeCacheErr);
+      }
+    }
+
     if (typeof handlerFn === "function") {
       const previousHeadersPhase = setHeadersAccessPhase("route-handler");
       try {
         const response = await handlerFn(request, { params });
         const dynamicUsedInHandler = consumeDynamicUsage();
+        const handlerSetCacheControl = response.headers.has("cache-control");
 
         // Apply Cache-Control from route segment config (export const revalidate = N).
         // Runtime request APIs like headers() / cookies() make GET handlers dynamic,
@@ -1983,11 +2181,43 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
           revalidateSeconds !== null &&
           !dynamicUsedInHandler &&
           (method === "GET" || isAutoHead) &&
-          !response.headers.has("cache-control")
+          !handlerSetCacheControl
         ) {
           response.headers.set("cache-control", "s-maxage=" + revalidateSeconds + ", stale-while-revalidate");
         }
 
+        // ISR cache write for route handlers (production, MISS).
+        // Store the raw handler response before cookie/middleware transforms
+        // (those are request-specific and shouldn't be cached).
+        if (
+          process.env.NODE_ENV === "production" &&
+          revalidateSeconds !== null &&
+          handler.dynamic !== "force-dynamic" &&
+          !dynamicUsedInHandler &&
+          (method === "GET" || isAutoHead) &&
+          !handlerSetCacheControl
+        ) {
+          response.headers.set("X-Vinext-Cache", "MISS");
+          const __routeClone = response.clone();
+          const __routeKey = __isrRouteKey(cleanPathname);
+          const __revalSecs = revalidateSeconds;
+          const __routeTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
+          const __routeWritePromise = (async () => {
+            try {
+              const __buf = await __routeClone.arrayBuffer();
+              const __hdrs = {};
+              __routeClone.headers.forEach(function(v, k) {
+                if (k !== "x-vinext-cache" && k !== "cache-control") __hdrs[k] = v;
+              });
+              await __isrSet(__routeKey, { kind: "APP_ROUTE", body: __buf, status: __routeClone.status, headers: __hdrs }, __revalSecs, __routeTags);
+              __isrDebug?.("route cache written", __routeKey);
+            } catch (__cacheErr) {
+              console.error("[vinext] ISR route cache write error:", __cacheErr);
+            }
+          })();
+          _getRequestExecutionContext()?.waitUntil(__routeWritePromise);
+        }
+
         // Collect any Set-Cookie headers from cookies().set()/delete() calls
         const pendingCookies = getAndClearPendingCookies();
         const draftCookie = getDraftModeCookieHeader();
@@ -2190,8 +2420,8 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
           });
           const __revalResult = await _runWithUnifiedCtx(__revalUCtx, async () => {
             _ensureFetchPatch();
-            setNavigationContext({ pathname: cleanPathname, searchParams: url.searchParams, params });
-            const __revalElement = await buildPageElement(route, params, undefined, url.searchParams);
+            setNavigationContext({ pathname: cleanPathname, searchParams: new URLSearchParams(), params });
+            const __revalElement = await buildPageElement(route, params, undefined, new URLSearchParams());
             const __revalOnError = createRscOnErrorHandler(request, cleanPathname, route.pattern);
             const __revalRscStream = renderToReadableStream(__revalElement, { onError: __revalOnError });
             // Tee RSC stream: one for SSR, one to capture rscData
@@ -2703,8 +2933,7 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
   // the HTML output has double <html>/<body> (root layout + global-error.tsx).
   // Discard it and re-render using renderErrorBoundaryPage which skips layouts
   // when the error falls through to global-error.tsx.
-  ${globalErrorVar
-        ? `
+  ${globalErrorVar ? `
   if (_rscErrorForRerender && !isRscRequest) {
     const _hasLocalBoundary = !!(route?.error?.default) || !!(route?.errors && route.errors.some(function(e) { return e?.default; }));
     if (!_hasLocalBoundary) {
@@ -2712,8 +2941,7 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
       if (cleanResp) return cleanResp;
     }
   }
-  `
-        : ""}
+  ` : ""}
 
   // Check for draftMode Set-Cookie header (from draftMode().enable()/disable())
   const draftCookie = getDraftModeCookieHeader();
@@ -2914,4 +3142,7 @@ if (import.meta.hot) {
 }
 `;
 }
+//#endregion
+export { generateRscEntry };
+
 //# sourceMappingURL=app-rsc-entry.js.map