vinext 0.0.45 → 0.0.47

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

@@ -1,8 +1,7 @@
 import { resolveEntryPath } from "./runtime-entry-module.js";
 import { isProxyFile } from "../server/middleware.js";
-import { generateMiddlewareMatcherCode, generateNormalizePathCode, generateRouteMatchNormalizationCode, generateSafeRegExpCode } from "../server/middleware-codegen.js";
+import { buildAppRscManifestCode } from "./app-rsc-manifest.js";
 import { generateDevOriginCheckCode } from "../server/dev-origin-check.js";
-import fs from "node:fs";
 //#region src/entries/app-rsc-entry.ts
 /**
 * App Router RSC entry generator.
@@ -13,29 +12,31 @@ import fs from "node:fs";
 *
 * Previously housed in server/app-dev-server.ts.
 */
-const configMatchersPath = resolveEntryPath("../config/config-matchers.js", import.meta.url);
-const requestPipelinePath = resolveEntryPath("../server/request-pipeline.js", import.meta.url);
+const DEFAULT_EXPIRE_TIME = 31536e3;
 const middlewareRequestHeadersPath = resolveEntryPath("../server/middleware-request-headers.js", import.meta.url);
-const requestContextShimPath = resolveEntryPath("../shims/request-context.js", import.meta.url);
 const normalizePathModulePath = resolveEntryPath("../server/normalize-path.js", import.meta.url);
-const appRouteHandlerRuntimePath = resolveEntryPath("../server/app-route-handler-runtime.js", import.meta.url);
-const appRouteHandlerPolicyPath = resolveEntryPath("../server/app-route-handler-policy.js", import.meta.url);
-const appRouteHandlerExecutionPath = resolveEntryPath("../server/app-route-handler-execution.js", import.meta.url);
+const appRscHandlerPath = resolveEntryPath("../server/app-rsc-handler.js", import.meta.url);
+const appRouteHandlerDispatchPath = resolveEntryPath("../server/app-route-handler-dispatch.js", import.meta.url);
 const appServerActionExecutionPath = resolveEntryPath("../server/app-server-action-execution.js", import.meta.url);
-const appRouteHandlerCachePath = resolveEntryPath("../server/app-route-handler-cache.js", import.meta.url);
-const appPageCachePath = resolveEntryPath("../server/app-page-cache.js", import.meta.url);
+const appRscErrorsPath = resolveEntryPath("../server/app-rsc-errors.js", import.meta.url);
 const appPageExecutionPath = resolveEntryPath("../server/app-page-execution.js", import.meta.url);
-const appPageBoundaryRenderPath = resolveEntryPath("../server/app-page-boundary-render.js", import.meta.url);
+const appFallbackRendererPath = resolveEntryPath("../server/app-fallback-renderer.js", import.meta.url);
 const appElementsPath = resolveEntryPath("../server/app-elements.js", import.meta.url);
 const appPageRouteWiringPath = resolveEntryPath("../server/app-page-route-wiring.js", import.meta.url);
-const appPageRenderPath = resolveEntryPath("../server/app-page-render.js", import.meta.url);
-const appPageResponsePath = resolveEntryPath("../server/app-page-response.js", import.meta.url);
-const cspPath = resolveEntryPath("../server/csp.js", import.meta.url);
+const appPageHeadPath = resolveEntryPath("../server/app-page-head.js", import.meta.url);
+const appPageParamsPath = resolveEntryPath("../server/app-page-params.js", import.meta.url);
+const appPageDispatchPath = resolveEntryPath("../server/app-page-dispatch.js", import.meta.url);
 const appPageRequestPath = resolveEntryPath("../server/app-page-request.js", import.meta.url);
-const appRouteHandlerResponsePath = resolveEntryPath("../server/app-route-handler-response.js", import.meta.url);
-const routeTriePath = resolveEntryPath("../routing/route-trie.js", import.meta.url);
-const metadataRoutesPath = resolveEntryPath("../server/metadata-routes.js", import.meta.url);
-const errorCausePath = resolveEntryPath("../utils/error-cause.js", import.meta.url);
+const appSegmentConfigPath = resolveEntryPath("../server/app-segment-config.js", import.meta.url);
+const appRscRouteMatchingPath = resolveEntryPath("../server/app-rsc-route-matching.js", import.meta.url);
+const rscStreamHintsPath = resolveEntryPath("../server/rsc-stream-hints.js", import.meta.url);
+const isrCachePath = resolveEntryPath("../server/isr-cache.js", import.meta.url);
+const thenableParamsShimPath = resolveEntryPath("../shims/thenable-params.js", import.meta.url);
+const appPageElementBuilderPath = resolveEntryPath("../server/app-page-element-builder.js", import.meta.url);
+const instrumentationRuntimePath = resolveEntryPath("../server/instrumentation-runtime.js", import.meta.url);
+const appRscErrorHandlerPath = resolveEntryPath("../server/app-rsc-error-handler.js", import.meta.url);
+const appRequestContextPath = resolveEntryPath("../server/app-request-context.js", import.meta.url);
+const appHookWarningSuppressionPath = resolveEntryPath("../server/app-hook-warning-suppression.js", import.meta.url);
 /**
 * Generate the virtual RSC entry module.
 *
@@ -55,134 +56,21 @@ function generateRscEntry(appDir, routes, middlewarePath, metadataRoutes, global
 	const headers = config?.headers ?? [];
 	const allowedOrigins = config?.allowedOrigins ?? [];
 	const bodySizeLimit = config?.bodySizeLimit ?? 1 * 1024 * 1024;
+	const expireTime = config?.expireTime ?? DEFAULT_EXPIRE_TIME;
 	const i18nConfig = config?.i18n ?? null;
 	const hasPagesDir = config?.hasPagesDir ?? false;
 	const publicFiles = config?.publicFiles ?? [];
-	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);
-				for (const layoutPath of ir.layoutPaths) getImportVar(layoutPath);
-			}
-		}
-	}
-	const routeEntries = routes.map((route, routeIdx) => {
-		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) => `        {
-          convention: ${JSON.stringify(ir.convention)},
-          targetPattern: ${JSON.stringify(ir.targetPattern)},
-          interceptLayouts: [${ir.layoutPaths.map((layoutPath) => getImportVar(layoutPath)).join(", ")}],
-          page: ${getImportVar(ir.pagePath)},
-          params: ${JSON.stringify(ir.params)},
-        }`);
-			return `      ${JSON.stringify(slot.key)}: {
-        name: ${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"},
-        loading: ${slot.loadingPath ? getImportVar(slot.loadingPath) : "null"},
-        error: ${slot.errorPath ? getImportVar(slot.errorPath) : "null"},
-        layoutIndex: ${slot.layoutIndex},
-        routeSegments: ${JSON.stringify(slot.routeSegments)},
-        intercepts: [
-${interceptEntries.join(",\n")}
-        ],
-      }`;
-		});
-		const layoutErrorVars = (route.layoutErrorPaths || []).map((ep) => ep ? getImportVar(ep) : "null");
-		return `  {
-    __buildTimeClassifications: __VINEXT_CLASS(${routeIdx}), // evaluated once at module load
-    __buildTimeReasons: __classDebug ? __VINEXT_CLASS_REASONS(${routeIdx}) : null,
-    pattern: ${JSON.stringify(route.pattern)},
-    patternParts: ${JSON.stringify(route.patternParts)},
-    isDynamic: ${route.isDynamic},
-    params: ${JSON.stringify(route.params)},
-    page: ${route.pagePath ? getImportVar(route.pagePath) : "null"},
-    routeHandler: ${route.routePath ? getImportVar(route.routePath) : "null"},
-    layouts: [${layoutVars.join(", ")}],
-    routeSegments: ${JSON.stringify(route.routeSegments)},
-    templateTreePositions: ${JSON.stringify(route.templateTreePositions)},
-    layoutTreePositions: ${JSON.stringify(route.layoutTreePositions)},
-    templates: [${templateVars.join(", ")}],
-    errors: [${layoutErrorVars.join(", ")}],
-    slots: {
-${slotEntries.join(",\n")}
-    },
-    loading: ${route.loadingPath ? getImportVar(route.loadingPath) : "null"},
-    error: ${route.errorPath ? getImportVar(route.errorPath) : "null"},
-    notFound: ${route.notFoundPath ? getImportVar(route.notFoundPath) : "null"},
-    notFounds: [${notFoundVars.join(", ")}],
-    forbidden: ${route.forbiddenPath ? getImportVar(route.forbiddenPath) : "null"},
-    unauthorized: ${route.unauthorizedPath ? getImportVar(route.unauthorizedPath) : "null"},
-  }`;
-	});
-	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},` : ""}
-  }`;
-		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)},
-  }`;
+	const { imports, routeEntries, metaRouteEntries, generateStaticParamsEntries, rootNotFoundVar, rootForbiddenVar, rootUnauthorizedVar, rootLayoutVars, globalErrorVar } = buildAppRscManifestCode({
+		routes,
+		metadataRoutes,
+		globalErrorPath
 	});
+	const loadPrerenderPagesRoutesCode = hasPagesDir ? `
+async function __loadPrerenderPagesRoutes() {
+  const __gspSsrEntry = await import.meta.viteRsc.loadModule("ssr", "index");
+  return __gspSsrEntry.pageRoutes;
+}
+` : "";
 	return `
 import {
   renderToReadableStream as _renderToReadableStream,
@@ -191,180 +79,91 @@ import {
   loadServerAction,
   createTemporaryReferenceSet,
 } from "@vitejs/plugin-rsc/rsc";
-import { AsyncLocalStorage } from "node:async_hooks";
+import { createRscRenderer } from ${JSON.stringify(rscStreamHintsPath)};
 
-// 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')));
-    }
-  }));
-}
+const renderToReadableStream = createRscRenderer(_renderToReadableStream);
 import { createElement } 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";
-import { NextRequest, NextFetchEvent } from "next/server";
+import { getNavigationContext as _getNavigationContext } from "next/navigation";
+import { headersContextFromRequest, getDraftModeCookieHeader, getAndClearPendingCookies, consumeDynamicUsage, consumeInvalidDynamicUsageError, setHeadersAccessPhase } from "next/headers";
 import { mergeMetadata, resolveModuleMetadata, mergeViewport, resolveModuleViewport } from "vinext/metadata";
 ${middlewarePath ? `import * as middlewareModule from ${JSON.stringify(middlewarePath.replace(/\\/g, "/"))};` : ""}
-${instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(instrumentationPath.replace(/\\/g, "/"))};` : ""}
-${effectiveMetaRoutes.length > 0 ? `import { sitemapToXml, robotsToText, manifestToJson } from ${JSON.stringify(metadataRoutesPath)};` : ""}
-import { requestContextFromRequest, normalizeHost, matchRedirect, matchRewrite, matchHeaders, isExternalUrl, proxyExternalRequest, sanitizeDestination } from ${JSON.stringify(configMatchersPath)};
+${instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(instrumentationPath.replace(/\\/g, "/"))};
+import { ensureInstrumentationRegistered as __ensureInstrumentationRegistered } from ${JSON.stringify(instrumentationRuntimePath)};` : ""}
+import { createAppRscHandler as __createAppRscHandler } from ${JSON.stringify(appRscHandlerPath)};
 import { decodePathParams as __decodePathParams } from ${JSON.stringify(normalizePathModulePath)};
 import { buildRequestHeadersFromMiddlewareResponse as __buildRequestHeadersFromMiddlewareResponse } from ${JSON.stringify(middlewareRequestHeadersPath)};
-import { validateCsrfOrigin, validateServerActionPayload, validateImageUrl, guardProtocolRelativeUrl, hasBasePath, stripBasePath, normalizeTrailingSlash, processMiddlewareHeaders } from ${JSON.stringify(requestPipelinePath)};
-import {
-  isKnownDynamicAppRoute as __isKnownDynamicAppRoute,
-} from ${JSON.stringify(appRouteHandlerRuntimePath)};
 import {
-  getAppRouteHandlerRevalidateSeconds as __getAppRouteHandlerRevalidateSeconds,
-  hasAppRouteHandlerDefaultExport as __hasAppRouteHandlerDefaultExport,
-  resolveAppRouteHandlerMethod as __resolveAppRouteHandlerMethod,
-  shouldReadAppRouteHandlerCache as __shouldReadAppRouteHandlerCache,
-} from ${JSON.stringify(appRouteHandlerPolicyPath)};
-import {
-  executeAppRouteHandler as __executeAppRouteHandler,
-} from ${JSON.stringify(appRouteHandlerExecutionPath)};
+  dispatchAppRouteHandler as __dispatchAppRouteHandler,
+} from ${JSON.stringify(appRouteHandlerDispatchPath)};
 import {
   handleProgressiveServerActionRequest as __handleProgressiveServerActionRequest,
+  handleServerActionRscRequest as __handleServerActionRscRequest,
+  readActionBodyWithLimit as __readBodyWithLimit,
+  readActionFormDataWithLimit as __readFormDataWithLimit,
 } from ${JSON.stringify(appServerActionExecutionPath)};
-import { readAppRouteHandlerCacheResponse as __readAppRouteHandlerCacheResponse } from ${JSON.stringify(appRouteHandlerCachePath)};
-import { readAppPageCacheResponse as __readAppPageCacheResponse } from ${JSON.stringify(appPageCachePath)};
+import {
+  sanitizeErrorForClient as __sanitizeErrorForClient,
+} from ${JSON.stringify(appRscErrorsPath)};
+import { createAppRscOnErrorHandler } from ${JSON.stringify(appRscErrorHandlerPath)};
 import {
   buildAppPageFontLinkHeader as __buildAppPageFontLinkHeader,
-  buildAppPageSpecialErrorResponse as __buildAppPageSpecialErrorResponse,
-  readAppPageTextStream as __readAppPageTextStream,
   resolveAppPageSpecialError as __resolveAppPageSpecialError,
-  teeAppPageRscStreamForCapture as __teeAppPageRscStreamForCapture,
 } from ${JSON.stringify(appPageExecutionPath)};
 import {
-  renderAppPageErrorBoundary as __renderAppPageErrorBoundary,
-  renderAppPageHttpAccessFallback as __renderAppPageHttpAccessFallback,
-} from ${JSON.stringify(appPageBoundaryRenderPath)};
+  createAppFallbackRenderer as __createAppFallbackRenderer,
+} from ${JSON.stringify(appFallbackRendererPath)};
 import {
   APP_INTERCEPTION_CONTEXT_KEY as __APP_INTERCEPTION_CONTEXT_KEY,
   createAppPayloadRouteId as __createAppPayloadRouteId,
 } from ${JSON.stringify(appElementsPath)};
 import {
-  buildAppPageElements as __buildAppPageElements,
-  createAppPageTreePath as __createAppPageTreePath,
   resolveAppPageChildSegments as __resolveAppPageChildSegments,
 } from ${JSON.stringify(appPageRouteWiringPath)};
+import { buildPageElements as __buildPageElements } from ${JSON.stringify(appPageElementBuilderPath)};
+import {
+  resolveAppPageSegmentParams as __resolveAppPageSegmentParams,
+} from ${JSON.stringify(appPageParamsPath)};
 import {
-  renderAppPageLifecycle as __renderAppPageLifecycle,
-} from ${JSON.stringify(appPageRenderPath)};
+  collectAppPageSearchParams as __collectAppPageSearchParams,
+} from ${JSON.stringify(appPageHeadPath)};
 import {
-  mergeMiddlewareResponseHeaders as __mergeMiddlewareResponseHeaders,
-} from ${JSON.stringify(appPageResponsePath)};
-import { getScriptNonceFromHeaderSources as __getScriptNonceFromHeaderSources } from ${JSON.stringify(cspPath)};
+  dispatchAppPage as __dispatchAppPage,
+} from ${JSON.stringify(appPageDispatchPath)};
 import {
-  resolveAppPageActionRerenderTarget as __resolveAppPageActionRerenderTarget,
-  buildAppPageElement as __buildAppPageElement,
-  resolveAppPageIntercept as __resolveAppPageIntercept,
-  validateAppPageDynamicParams as __validateAppPageDynamicParams,
+  resolveAppPageGenerateStaticParamsSources as __resolveAppPageGenerateStaticParamsSources,
 } from ${JSON.stringify(appPageRequestPath)};
 import {
-  applyRouteHandlerMiddlewareContext as __applyRouteHandlerMiddlewareContext,
-} from ${JSON.stringify(appRouteHandlerResponsePath)};
-import { _consumeRequestScopedCacheLife, getCacheHandler } from "next/cache";
-import { getRequestExecutionContext as _getRequestExecutionContext } from ${JSON.stringify(requestContextShimPath)};
-import { ensureFetchPatch as _ensureFetchPatch, getCollectedFetchTags, setCurrentFetchSoftTags } from "vinext/fetch-cache";
-import { buildRouteTrie as _buildRouteTrie, trieMatch as _trieMatch } from ${JSON.stringify(routeTriePath)};
+  resolveAppPageFetchCacheMode as __resolveAppPageFetchCacheMode,
+  resolveAppPageSegmentConfig as __resolveAppPageSegmentConfig,
+} from ${JSON.stringify(appSegmentConfigPath)};
+import { makeThenableParams } from ${JSON.stringify(thenableParamsShimPath)};
+import {
+  createAppRscRouteMatcher as __createAppRscRouteMatcher,
+} from ${JSON.stringify(appRscRouteMatchingPath)};
+import {
+  appIsrHtmlKey as __isrHtmlKey,
+  appIsrRscKey as __isrRscKey,
+  appIsrRouteKey as __isrRouteKey,
+  isrGet as __isrGet,
+  isrSet as __isrSet,
+  triggerBackgroundRegeneration as __triggerBackgroundRegeneration,
+} from ${JSON.stringify(isrCachePath)};
 // Import server-only state module to register ALS-backed accessors.
 import "vinext/navigation-state";
-import { runWithRequestContext as _runWithUnifiedCtx, createRequestContext as _createUnifiedCtx } from "vinext/unified-request-context";
 import { reportRequestError as _reportRequestError } from "vinext/instrumentation";
-import { flattenErrorCauses as __flattenErrorCauses } from ${JSON.stringify(errorCausePath)};
 import { getSSRFontLinks as _getSSRFontLinks, getSSRFontStyles as _getSSRFontStylesGoogle, getSSRFontPreloads as _getSSRFontPreloadsGoogle } from "next/font/google";
 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` : ""}
+${hasPagesDir ? `// Pages Router routes are loaded lazily from the SSR environment for internal prerender requests.` : ""}
 
-// ALS used to suppress the expected "Invalid hook call" dev warning when
-// layout/page components are probed outside React's render cycle. Patching
-// console.error once at module load (instead of per-request) avoids the
-// concurrent-request issue where request A's suppression filter could
-// swallow real errors from request B.
-const _suppressHookWarningAls = new AsyncLocalStorage();
-const _origConsoleError = console.error;
-console.error = (...args) => {
-  if (_suppressHookWarningAls.getStore() === true &&
-      typeof args[0] === "string" &&
-      args[0].includes("Invalid hook call")) return;
-  _origConsoleError.apply(console, args);
-};
-
-// Set navigation context in the ALS-backed store. "use client" components
-// rendered during SSR need the pathname/searchParams/params but the SSR
-// environment has a separate module instance of next/navigation.
-// Use _getNavigationContext() to read the current context — never cache
-// it in a module-level variable (that would leak between concurrent requests).
-function setNavigationContext(ctx) {
-  _setNavigationContextOrig(ctx);
-}
+// Suppress expected "Invalid hook call" dev warning when layout/page
+// components are probed outside React's render cycle. The import patches
+// console.error once at module load (side-effect) and exposes the ALS
+// so per-route dispatch can opt into suppression via .run(true, ...).
+import { suppressHookWarningAls } from ${JSON.stringify(appHookWarningSuppressionPath)};
+import { clearAppRequestContext as __clearRequestContext, setAppNavigationContext as setNavigationContext } from ${JSON.stringify(appRequestContextPath)};
 
-// ISR cache is disabled in dev mode — every request re-renders fresh,
-// matching Next.js dev behavior. Cache-Control headers are still emitted
-// based on export const revalidate for testing purposes.
-// Production ISR uses the MemoryCacheHandler (or configured KV handler).
-//
-// These helpers are inlined instead of imported from isr-cache.js because
-// the virtual RSC entry module runs in the RSC Vite environment which
-// cannot use dynamic imports at the module-evaluation level for server-only
-// modules, and direct imports must use the pre-computed absolute paths.
-async function __isrGet(key) {
-  const handler = getCacheHandler();
-  const result = await handler.get(key);
-  if (!result || !result.value) return null;
-  return { value: result, isStale: result.cacheState === "stale" };
-}
-async function __isrSet(key, data, revalidateSeconds, tags) {
-  const handler = getCacheHandler();
-  await handler.set(key, data, { revalidate: revalidateSeconds, tags: Array.isArray(tags) ? 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);
-    }
-  }
-  return tags;
-}
 // Note: cache entries are written with \`headers: undefined\`. Next.js stores
 // response headers (e.g. set-cookie from cookies().set() during render) in the
 // cache entry so they can be replayed on HIT. We don't do this because:
@@ -375,68 +174,6 @@ function __pageCacheTags(pathname, extraTags) {
 // In practice this means ISR-cached responses won't replay render-time set-cookie
 // headers — but that case is already prevented by the dynamic-usage opt-out.
 // TODO: capture render-time response headers for full Next.js parity.
-const __pendingRegenerations = new Map();
-function __triggerBackgroundRegeneration(key, renderFn) {
-  if (__pendingRegenerations.has(key)) return;
-  const promise = renderFn()
-    .catch((err) => console.error("[vinext] ISR regen failed for " + key + ":", err))
-    .finally(() => __pendingRegenerations.delete(key));
-  __pendingRegenerations.set(key, promise);
-  const ctx = _getRequestExecutionContext();
-  if (ctx && typeof ctx.waitUntil === "function") ctx.waitUntil(promise);
-}
-// HTML and RSC are stored under separate keys — matching Next.js's file-system
-// layout (.html / .rsc) — so each request type reads and writes its own key
-// independently with no races or partial-entry sentinels.
-//
-// Key format: "app:<buildId>:<pathname>:<suffix>"
-// Long-pathname fallback: "app:<buildId>:__hash:<fnv1a64(pathname)>:<suffix>"
-// Without buildId (should not happen in production): "app:<pathname>:<suffix>"
-// The 200-char threshold keeps the full key well under Cloudflare KV's 512-byte limit
-// even after adding the build ID and suffix. FNV-1a 64 is used for the hash (two
-// 32-bit rounds) to give a ~64-bit output with negligible collision probability for
-// realistic pathname lengths.
-// Keep prefix construction and hashing logic in sync with isrCacheKey() in server/isr-cache.ts.
-function __isrFnv1a64(s) {
-  // h1 uses the standard FNV-1a 32-bit offset basis (0x811c9dc5).
-  let h1 = 0x811c9dc5;
-  for (let i = 0; i < s.length; i++) { h1 ^= s.charCodeAt(i); h1 = (h1 * 0x01000193) >>> 0; }
-  // h2 uses a different seed (0x050c5d1f — the FNV-1a hash of the string "vinext")
-  // so the two rounds are independently seeded and their outputs are decorrelated.
-  // Concatenating two independently-seeded 32-bit FNV-1a hashes gives an effective
-  // 64-bit hash. A random non-standard seed would also work; we derive it from a
-  // fixed string so the choice is auditable and deterministic across rebuilds.
-  let h2 = 0x050c5d1f;
-  for (let i = 0; i < s.length; i++) { h2 ^= s.charCodeAt(i); h2 = (h2 * 0x01000193) >>> 0; }
-  return h1.toString(36) + h2.toString(36);
-}
-function __isrCacheKey(pathname, suffix) {
-  const normalized = pathname === "/" ? "/" : pathname.replace(/\\/$/, "");
-  // __VINEXT_BUILD_ID is replaced at compile time by Vite's define plugin.
-  const buildId = process.env.__VINEXT_BUILD_ID;
-  const prefix = buildId ? "app:" + buildId : "app";
-  const key = prefix + ":" + normalized + ":" + suffix;
-  if (key.length <= 200) return key;
-  // Pathname too long — hash it to keep under KV's 512-byte key limit.
-  return prefix + ":__hash:" + __isrFnv1a64(normalized) + ":" + suffix;
-}
-function __isrHtmlKey(pathname) { return __isrCacheKey(pathname, "html"); }
-function __isrRscKey(pathname, mountedSlotsHeader) {
-  if (!mountedSlotsHeader) return __isrCacheKey(pathname, "rsc");
-  return __isrCacheKey(pathname, "rsc:" + __isrFnv1a64(mountedSlotsHeader));
-}
-function __normalizeMountedSlotsHeader(raw) {
-  if (!raw) return null;
-  const normalized = Array.from(
-    new Set(
-      raw
-        .split(/\\s+/)
-        .filter(Boolean),
-    ),
-  ).sort().join(" ");
-  return normalized || null;
-}
-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.
@@ -454,173 +191,19 @@ const __classDebug = process.env.VINEXT_DEBUG_CLASSIFICATION
     }
   : undefined;
 
-// Normalize null-prototype objects from matchPattern() into thenable objects
-// that work both as Promises (for Next.js 15+ async params) and as plain
-// objects with synchronous property access (for pre-15 code like params.id).
-//
-// matchPattern() uses Object.create(null), producing objects without
-// Object.prototype. The RSC serializer rejects these. Spreading ({...obj})
-// restores a normal prototype. Object.assign onto the Promise preserves
-// synchronous property access (params.id, params.slug) that existing
-// components and test fixtures rely on.
-function makeThenableParams(obj) {
-  const plain = { ...obj };
-  return Object.assign(Promise.resolve(plain), plain);
-}
-
-// djb2 hash — matches Next.js's stringHash for digest generation.
-// Produces a stable numeric string from error message + stack.
-function __errorDigest(str) {
-  let hash = 5381;
-  for (let i = str.length - 1; i >= 0; i--) {
-    hash = (hash * 33) ^ str.charCodeAt(i);
-  }
-  return (hash >>> 0).toString();
-}
-
-// Sanitize an error for client consumption. In production, replaces the error
-// with a generic Error that only carries a digest hash (matching Next.js
-// behavior). In development, returns the original error for debugging.
-// Navigation errors (redirect, notFound, etc.) are always passed through
-// unchanged since their digests are used for client-side routing.
-function __sanitizeErrorForClient(error) {
-  // Navigation errors must pass through with their digest intact
-  if (__resolveAppPageSpecialError(error)) {
-    return error;
-  }
-  // In development, pass through the original error for debugging
-  if (process.env.NODE_ENV !== "production") {
-    return error;
-  }
-  // In production, create a sanitized error with only a digest hash
-  const msg = error instanceof Error ? error.message : String(error);
-  const stack = error instanceof Error ? (error.stack || "") : "";
-  const sanitized = new Error(
-    "An error occurred in the Server Components render. " +
-    "The specific message is omitted in production builds to avoid leaking sensitive details. " +
-    "A digest property is included on this error instance which may provide additional details about the nature of the error."
-  );
-  sanitized.digest = __errorDigest(msg + stack);
-  return sanitized;
-}
-
-// onError callback for renderToReadableStream — preserves the digest for
-// Next.js navigation errors (redirect, notFound, forbidden, unauthorized)
-// thrown during RSC streaming (e.g. inside Suspense boundaries).
-// For non-navigation errors in production, generates a digest hash so the
-// error can be correlated with server logs without leaking details.
-function rscOnError(error, requestInfo, errorContext) {
-  if (error && typeof error === "object" && "digest" in error) {
-    return String(error.digest);
-  }
-
-  // In dev, detect the "Only plain objects" RSC serialization error and emit
-  // an actionable hint. This error occurs when a Server Component passes a
-  // class instance, ES module namespace object, or null-prototype object as a
-  // prop to a Client Component.
-  //
-  // Root cause: Vite bundles modules as true ESM (module namespace objects
-  // have a null-like internal slot), while Next.js's webpack build produces
-  // plain CJS-wrapped objects with __esModule:true. React's RSC serializer
-  // accepts the latter as plain objects but rejects the former — which means
-  // code that accidentally passes "import * as X" works in webpack/Next.js
-  // but correctly fails in vinext.
-  //
-  // Common triggers:
-  //   - "import * as utils from './utils'" passed as a prop
-  //   - class instances (new Foo()) passed as props
-  //   - Date / Map / Set instances passed as props
-  //   - Objects with Object.create(null) (null prototype)
-  if (
-    process.env.NODE_ENV !== "production" &&
-    error instanceof Error &&
-    error.message.includes("Only plain objects, and a few built-ins, can be passed to Client Components")
-  ) {
-    console.error(
-      "[vinext] RSC serialization error: a non-plain object was passed from a Server Component to a Client Component.\\n" +
-      "\\n" +
-      "Common causes:\\n" +
-      "  * Passing a module namespace (import * as X) directly as a prop.\\n" +
-      "    Unlike Next.js (webpack), Vite produces real ESM module namespace objects\\n" +
-      "    which are not serializable. Fix: pass individual values instead,\\n" +
-      "    e.g. <Comp value={module.value} />\\n" +
-      "  * Passing a class instance (new Foo()) as a prop.\\n" +
-      "    Fix: convert to a plain object, e.g. { id: foo.id, name: foo.name }\\n" +
-      "  * Passing a Date, Map, or Set. Use .toISOString(), [...map.entries()], etc.\\n" +
-      "  * Passing Object.create(null). Use { ...obj } to restore a prototype.\\n" +
-      "\\n" +
-      "Original error:",
-      error.message,
-    );
-    return undefined;
-  }
-
-  if (requestInfo && errorContext && error) {
-    _reportRequestError(
-      error instanceof Error ? error : new Error(String(error)),
-      requestInfo,
-      errorContext,
-    );
-  }
-
-  // In production, generate a digest hash for non-navigation errors
-  if (process.env.NODE_ENV === "production" && error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    const stack = error instanceof Error ? (error.stack || "") : "";
-    return __errorDigest(msg + stack);
-  }
-  return undefined;
-}
-
-function createRscOnErrorHandler(request, pathname, routePath) {
-  const requestInfo = {
-    path: pathname,
-    method: request.method,
-    headers: Object.fromEntries(request.headers.entries()),
-  };
-  const errorContext = {
-    routerKind: "App Router",
-    routePath: routePath || pathname,
-    routeType: "render",
-  };
-  return function(error) {
-    return rscOnError(error, requestInfo, errorContext);
-  };
+function __resolveRouteFetchCacheMode(route) {
+  return __resolveAppPageFetchCacheMode({
+    layouts: route.layouts,
+    page: route.page,
+  });
 }
 
 ${imports.join("\n")}
 
-${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
-// handled" guarantee while not blocking V8 isolate initialization.
-// On Cloudflare Workers, module evaluation happens synchronously in the isolate
-// startup phase; a top-level await extends that phase and increases cold-start
-// wall time for all requests, not just the first.
-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 () => {
-    if (typeof _instrumentation.register === "function") {
-      await _instrumentation.register();
-    }
-    // Store the onRequestError handler on globalThis so it is visible to
-    // reportRequestError() (imported as _reportRequestError above) regardless
-    // of which Vite environment module graph it is called from. With
-    // @vitejs/plugin-rsc the RSC and SSR environments run in the same Node.js
-    // process and share globalThis. With @cloudflare/vite-plugin everything
-    // runs inside the Worker so globalThis is the Worker's global — also correct.
-    if (typeof _instrumentation.onRequestError === "function") {
-      globalThis.__VINEXT_onRequestErrorHandler__ = _instrumentation.onRequestError;
-    }
-    __instrumentationInitialized = true;
-  })();
-  return __instrumentationInitPromise;
-}` : ""}
+${instrumentationPath ? `// Lazy instrumentation initialisation is handled by ensureInstrumentationRegistered
+// (imported from vinext/instrumentation-runtime). The generated entry only passes
+// the user module in; all bookkeeping (initialized flag, shared promise, prerender
+// skip) lives in the typed helper so it can be unit-tested independently.` : ""}
 
 // Build-time layout classification dispatch. Replaced in generateBundle
 // with a switch statement that returns a pre-computed per-layout
@@ -643,7 +226,7 @@ function __VINEXT_CLASS_REASONS(routeIdx) {
 const routes = [
 ${routeEntries.join(",\n")}
 ];
-const _routeTrie = _buildRouteTrie(routes);
+const __routeMatcher = __createAppRscRouteMatcher(routes);
 
 const metadataRoutes = [
 ${metaRouteEntries.join(",\n")}
@@ -653,176 +236,43 @@ const rootNotFoundModule = ${rootNotFoundVar ? rootNotFoundVar : "null"};
 const rootForbiddenModule = ${rootForbiddenVar ? rootForbiddenVar : "null"};
 const rootUnauthorizedModule = ${rootUnauthorizedVar ? rootUnauthorizedVar : "null"};
 const rootLayouts = [${rootLayoutVars.join(", ")}];
-const __APP_PAGE_EMPTY_MW_CTX = { headers: null, status: null };
 
-/**
- * Render an HTTP access fallback page (not-found/forbidden/unauthorized) with layouts and noindex meta.
- * Returns null if no matching component is available.
- *
- * @param opts.boundaryComponent - Override the boundary component (for layout-level notFound)
- * @param opts.layouts - Override the layouts to wrap with (for layout-level notFound, excludes the throwing layout)
- */
-async function renderHTTPAccessFallbackPage(route, statusCode, isRscRequest, request, opts, scriptNonce, middlewareContext) {
-  return __renderAppPageHttpAccessFallback({
-    boundaryComponent: opts?.boundaryComponent ?? null,
+const createRscOnErrorHandler = (request, pathname, routePath) =>
+  createAppRscOnErrorHandler(_reportRequestError, request, pathname, routePath);
+
+const __fallbackRenderer = __createAppFallbackRenderer({
+  rootBoundaries: {
+    rootForbiddenModule,
+    rootLayouts,
+    rootNotFoundModule,
+    rootUnauthorizedModule,
+  },
+  globalErrorModule: ${globalErrorVar ? globalErrorVar : "null"},
+  metadataRoutes,
+  ssrLoader() {
+    return import.meta.viteRsc.loadModule("ssr", "index");
+  },
+  fontProviders: {
     buildFontLinkHeader: __buildAppPageFontLinkHeader,
-    clearRequestContext() {
-      setHeadersContext(null);
-      setNavigationContext(null);
-    },
-    createRscOnErrorHandler(pathname, routePath) {
-      return createRscOnErrorHandler(request, pathname, routePath);
-    },
     getFontLinks: _getSSRFontLinks,
     getFontPreloads: _getSSRFontPreloads,
     getFontStyles: _getSSRFontStyles,
-    getNavigationContext: _getNavigationContext,
-    globalErrorModule: ${globalErrorVar ? globalErrorVar : "null"},
-    isRscRequest,
-    layoutModules: opts?.layouts ?? null,
-    loadSsrHandler() {
-      return import.meta.viteRsc.loadModule("ssr", "index");
-    },
-    makeThenableParams,
-    matchedParams: opts?.matchedParams ?? route?.params ?? {},
-    middlewareContext: middlewareContext ?? __APP_PAGE_EMPTY_MW_CTX,
-    requestUrl: request.url,
-    resolveChildSegments: __resolveAppPageChildSegments,
-    rootForbiddenModule: rootForbiddenModule,
-    rootLayouts: rootLayouts,
-    rootNotFoundModule: rootNotFoundModule,
-    rootUnauthorizedModule: rootUnauthorizedModule,
-    route,
-    renderToReadableStream,
-    scriptNonce,
-    statusCode,
-  });
-}
-
-/** Convenience: render a not-found page (404) */
-async function renderNotFoundPage(route, isRscRequest, request, matchedParams, scriptNonce, middlewareContext) {
-  return renderHTTPAccessFallbackPage(route, 404, isRscRequest, request, { matchedParams }, scriptNonce, middlewareContext);
-}
-
-/**
- * Render an error.tsx boundary page when a server component or generateMetadata() throws.
- * Returns null if no error boundary component is available for this route.
- *
- * Next.js returns HTTP 200 when error.tsx catches an error (the error is "handled"
- * by the boundary). This matches that behavior intentionally.
- */
-async function renderErrorBoundaryPage(route, error, isRscRequest, request, matchedParams, scriptNonce, middlewareContext) {
-  return __renderAppPageErrorBoundary({
-    buildFontLinkHeader: __buildAppPageFontLinkHeader,
-    clearRequestContext() {
-      setHeadersContext(null);
-      setNavigationContext(null);
-    },
-    createRscOnErrorHandler(pathname, routePath) {
-      return createRscOnErrorHandler(request, pathname, routePath);
-    },
-    error,
-    getFontLinks: _getSSRFontLinks,
-    getFontPreloads: _getSSRFontPreloads,
-    getFontStyles: _getSSRFontStyles,
-    getNavigationContext: _getNavigationContext,
-    globalErrorModule: ${globalErrorVar ? globalErrorVar : "null"},
-    isRscRequest,
-    loadSsrHandler() {
-      return import.meta.viteRsc.loadModule("ssr", "index");
-    },
-    makeThenableParams,
-    matchedParams: matchedParams ?? route?.params ?? {},
-    middlewareContext: middlewareContext ?? __APP_PAGE_EMPTY_MW_CTX,
-    requestUrl: request.url,
-    resolveChildSegments: __resolveAppPageChildSegments,
-    rootLayouts: rootLayouts,
-    route,
-    renderToReadableStream,
-    sanitizeErrorForClient: __sanitizeErrorForClient,
-    scriptNonce,
-  });
-}
+  },
+  makeThenableParams,
+  sanitizer: __sanitizeErrorForClient,
+  rscRenderer: renderToReadableStream,
+  getNavigationContext: _getNavigationContext,
+  resolveChildSegments: __resolveAppPageChildSegments,
+  clearRequestContext() {
+    __clearRequestContext();
+  },
+  createRscOnErrorHandler(request, pathname, routePath) {
+    return createRscOnErrorHandler(request, pathname, routePath);
+  },
+});
 
 function matchRoute(url) {
-  const pathname = url.split("?")[0];
-  let normalizedUrl = pathname === "/" ? "/" : pathname.replace(/\\/$/, "");
-   // NOTE: Do NOT decodeURIComponent here. The caller is responsible for decoding
-   // the pathname exactly once at the request entry point. Decoding again here
-   // would cause inconsistent path matching between middleware and routing.
-  const urlParts = normalizedUrl.split("/").filter(Boolean);
-  return _trieMatch(_routeTrie, urlParts);
-}
-
-function __createStaticFileSignal(pathname, _mwCtx) {
-  const headers = new Headers({
-    "x-vinext-static-file": encodeURIComponent(pathname),
-  });
-  if (_mwCtx.headers) {
-    for (const [key, value] of _mwCtx.headers) {
-      headers.append(key, value);
-    }
-  }
-  return new Response(null, {
-    status: _mwCtx.status ?? 200,
-    headers,
-  });
-}
-
-// matchPattern is kept for findIntercept (linear scan over small interceptLookup array).
-function matchPattern(urlParts, patternParts) {
-  const params = Object.create(null);
-  for (let i = 0; i < patternParts.length; i++) {
-    const pp = patternParts[i];
-    if (pp.endsWith("+")) {
-      if (i !== patternParts.length - 1) return null;
-      const paramName = pp.slice(1, -1);
-      const remaining = urlParts.slice(i);
-      if (remaining.length === 0) return null;
-      params[paramName] = remaining;
-      return params;
-    }
-    if (pp.endsWith("*")) {
-      if (i !== patternParts.length - 1) return null;
-      const paramName = pp.slice(1, -1);
-      params[paramName] = urlParts.slice(i);
-      return params;
-    }
-    if (pp.startsWith(":")) {
-      if (i >= urlParts.length) return null;
-      params[pp.slice(1)] = urlParts[i];
-      continue;
-    }
-    if (i >= urlParts.length || urlParts[i] !== pp) return null;
-  }
-  if (urlParts.length !== patternParts.length) return null;
-  return params;
-}
-
-function mergeMatchedParams(sourceParams, targetParams) {
-  return Object.assign(Object.create(null), sourceParams, targetParams);
-}
-
-// Build a global intercepting route lookup for RSC navigation.
-// Maps target URL patterns to { sourceRouteIndex, slotKey, interceptPage, interceptLayouts, params }.
-const interceptLookup = [];
-for (let ri = 0; ri < routes.length; ri++) {
-  const r = routes[ri];
-  if (!r.slots) continue;
-  for (const [slotKey, slotMod] of Object.entries(r.slots)) {
-    if (!slotMod.intercepts) continue;
-    for (const intercept of slotMod.intercepts) {
-      interceptLookup.push({
-        sourceRouteIndex: ri,
-        slotKey,
-        targetPattern: intercept.targetPattern,
-        targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
-        interceptLayouts: intercept.interceptLayouts,
-        page: intercept.page,
-        params: intercept.params,
-      });
-    }
-  }
+  return __routeMatcher.matchRoute(url);
 }
 
 /**
@@ -830,188 +280,23 @@ for (let ri = 0; ri < routes.length; ri++) {
  * Returns the match info or null.
  */
 function findIntercept(pathname, sourcePathname = null) {
-  const urlParts = pathname.split("/").filter(Boolean);
-  for (const entry of interceptLookup) {
-    const params = matchPattern(urlParts, entry.targetPatternParts);
-    if (params !== null) {
-      let sourceParams = Object.create(null);
-      if (sourcePathname !== null) {
-        const sourceRoute = routes[entry.sourceRouteIndex];
-        const sourceParts = sourcePathname.split("/").filter(Boolean);
-        const matchedSourceParams = sourceRoute
-          ? matchPattern(sourceParts, sourceRoute.patternParts)
-          : null;
-        if (matchedSourceParams !== null) {
-          sourceParams = matchedSourceParams;
-        }
-      }
-      return { ...entry, matchedParams: mergeMatchedParams(sourceParams, params) };
-    }
-  }
-  return null;
+  return __routeMatcher.findIntercept(pathname, sourcePathname);
 }
 
 async function buildPageElements(route, params, routePath, pageRequest) {
-  const {
-    opts,
-    searchParams,
-    isRscRequest,
-    request,
-    mountedSlotsHeader,
-  } = pageRequest;
-  const hasPageModule = !!route.page;
-  const PageComponent = route.page?.default;
-  if (hasPageModule && !PageComponent) {
-    const _interceptionContext = opts?.interceptionContext ?? null;
-    const _noExportRouteId = __createAppPayloadRouteId(routePath, _interceptionContext);
-    let _noExportRootLayout = null;
-    if (route.layouts?.length > 0) {
-      // Compute the root layout tree path for this error payload using the
-      // canonical helper so it stays aligned with buildAppPageElements().
-      const _tp = route.layoutTreePositions?.[0] ?? 0;
-      _noExportRootLayout = __createAppPageTreePath(route.routeSegments, _tp);
-    }
-    return {
-      [__APP_INTERCEPTION_CONTEXT_KEY]: _interceptionContext,
-      __route: _noExportRouteId,
-      __rootLayout: _noExportRootLayout,
-      [_noExportRouteId]: createElement("div", null, "Page has no default export"),
-    };
-  }
-
-  // Resolve metadata and viewport from layouts and page.
-  //
-  // generateMetadata() accepts a "parent" (Promise of ResolvedMetadata) as its
-  // second argument (Next.js 13+). The parent resolves to the accumulated
-  // merged metadata of all ancestor segments, enabling patterns like:
-  //
-  //   const previousImages = (await parent).openGraph?.images ?? []
-  //   return { openGraph: { images: ['/new-image.jpg', ...previousImages] } }
-  //
-  // Next.js uses an eager-execution-with-serial-resolution approach:
-  // all generateMetadata() calls are kicked off concurrently, but each
-  // segment's "parent" promise resolves only after the preceding segment's
-  // metadata is resolved and merged. This preserves concurrency for I/O-bound
-  // work while guaranteeing that parent data is available when needed.
-  //
-  // We build a chain: layoutParentPromises[0] = Promise.resolve({}) (no parent
-  // for root layout), layoutParentPromises[i+1] resolves to merge(layouts[0..i]),
-  // and pageParentPromise resolves to merge(all layouts).
-  //
-  // IMPORTANT: Layout metadata errors are swallowed (.catch(() => null)) because
-  // a layout's generateMetadata() failing should not crash the page.
-  // Page metadata errors are NOT swallowed — if the page's generateMetadata()
-  // throws, the error propagates out of buildPageElement() so the caller can
-  // route it to the nearest error.tsx boundary (or global-error.tsx).
-  const layoutMods = route.layouts.filter(Boolean);
-
-  // Convert URLSearchParams → plain object for page generateMetadata() and
-  // pageProps.searchParams. Built before the layout loop so the page metadata
-  // call (below) and pageProps can reference the same object.
-  // NOTE: Layouts do NOT receive searchParams in generateMetadata() — only
-  // pages do. This matches Next.js behavior (resolve-metadata.ts:777).
-  const spObj = Object.create(null);
-  let hasSearchParams = false;
-  if (searchParams && searchParams.forEach) {
-    searchParams.forEach(function(v, k) {
-      hasSearchParams = true;
-      if (k in spObj) {
-        spObj[k] = Array.isArray(spObj[k]) ? spObj[k].concat(v) : [spObj[k], v];
-      } else {
-        spObj[k] = v;
-      }
-    });
-  }
-
-  // Build the parent promise chain and kick off metadata resolution in one pass.
-  // Each layout module is called exactly once. layoutMetaPromises[i] is the
-  // promise for layout[i]'s own metadata result.
-  //
-  // All calls are kicked off immediately (concurrent I/O), but each layout's
-  // "parent" promise only resolves after the preceding layout's metadata is done.
-  const layoutMetaPromises = [];
-  let accumulatedMetaPromise = Promise.resolve({});
-  for (let i = 0; i < layoutMods.length; i++) {
-    const parentForThisLayout = accumulatedMetaPromise;
-    // Kick off this layout's metadata resolution now (concurrent with others).
-    const metaPromise = resolveModuleMetadata(layoutMods[i], params, undefined, parentForThisLayout)
-      .catch((err) => { console.error("[vinext] Layout generateMetadata() failed:", err); return null; });
-    layoutMetaPromises.push(metaPromise);
-    // Advance accumulator: resolves to merged(layouts[0..i]) once layout[i] is done.
-    accumulatedMetaPromise = metaPromise.then(async (result) =>
-      result ? mergeMetadata([await parentForThisLayout, result]) : await parentForThisLayout
-    );
-  }
-  // Page's parent is the fully-accumulated layout metadata.
-  const pageParentPromise = accumulatedMetaPromise;
-
-  const [layoutMetaResults, layoutVpResults, pageMeta, pageVp] = await Promise.all([
-    Promise.all(layoutMetaPromises),
-    Promise.all(layoutMods.map((mod) => resolveModuleViewport(mod, params).catch((err) => { console.error("[vinext] Layout generateViewport() failed:", err); return null; }))),
-    route.page ? resolveModuleMetadata(route.page, params, spObj, pageParentPromise) : Promise.resolve(null),
-    route.page ? resolveModuleViewport(route.page, params) : Promise.resolve(null),
-  ]);
-
-  const metadataList = [...layoutMetaResults.filter(Boolean), ...(pageMeta ? [pageMeta] : [])];
-  const viewportList = [...layoutVpResults.filter(Boolean), ...(pageVp ? [pageVp] : [])];
-  const resolvedMetadata = metadataList.length > 0 ? mergeMetadata(metadataList) : null;
-  const resolvedViewport = mergeViewport(viewportList);
-
-  // Build the route tree from the leaf page, then delegate the boundary/layout/
-  // template/segment wiring to a typed runtime helper so the generated entry
-  // stays thin and the wiring logic can be unit tested directly.
-  const pageProps = { params: makeThenableParams(params) };
-  if (searchParams) {
-    // Always provide searchParams prop when the URL object is available, even
-    // when the query string is empty -- pages that do "await searchParams" need
-    // it to be a thenable rather than undefined.
-    pageProps.searchParams = makeThenableParams(spObj);
-    // If the URL has query parameters, mark the page as dynamic.
-    // In Next.js, only accessing the searchParams prop signals dynamic usage,
-    // but a Proxy-based approach doesn't work here because React's RSC debug
-    // serializer accesses properties on all props (e.g. $$typeof check in
-    // isClientReference), triggering the Proxy even when user code doesn't
-    // read searchParams. Checking for non-empty query params is a safe
-    // approximation: pages with query params in the URL are almost always
-    // dynamic, and this avoids false positives from React internals.
-    if (hasSearchParams) markDynamicUsage();
-  }
-  // mountedSlotsHeader is threaded through from the handler scope so every
-  // call site shares one source of truth for request-derived values. Reading
-  // the same header in two places invites silent drift when a future refactor
-  // changes only one of them.
-  const mountedSlotIds = mountedSlotsHeader
-    ? new Set(mountedSlotsHeader.split(" "))
-    : null;
-
-  return __buildAppPageElements({
-    element: PageComponent ? createElement(PageComponent, pageProps) : null,
-    globalErrorModule: ${globalErrorVar ? globalErrorVar : "null"},
-    isRscRequest,
-    mountedSlotIds,
-    makeThenableParams,
-    matchedParams: params,
-    resolvedMetadata,
-    resolvedViewport,
-    interceptionContext: opts?.interceptionContext ?? null,
+  return __buildPageElements({
+    route,
+    params,
     routePath,
+    pageRequest,
+    globalErrorModule: ${globalErrorVar ? globalErrorVar : "null"},
     rootNotFoundModule: ${rootNotFoundVar ? rootNotFoundVar : "null"},
-    route,
-    slotOverrides:
-      opts && opts.interceptSlotKey && opts.interceptPage
-        ? {
-            [opts.interceptSlotKey]: {
-              layoutModules: opts.interceptLayouts || null,
-              pageModule: opts.interceptPage,
-              params: opts.interceptParams || params,
-            },
-          }
-        : null,
+    rootForbiddenModule: ${rootForbiddenVar ? rootForbiddenVar : "null"},
+    rootUnauthorizedModule: ${rootUnauthorizedVar ? rootUnauthorizedVar : "null"},
+    metadataRoutes,
   });
 }
 
-${middlewarePath ? generateMiddlewareMatcherCode("modern") : ""}
-
 const __basePath = ${JSON.stringify(bp)};
 const __trailingSlash = ${JSON.stringify(ts)};
 const __i18nConfig = ${JSON.stringify(i18nConfig)};
@@ -1020,45 +305,10 @@ const __configRewrites = ${JSON.stringify(rewrites)};
 const __configHeaders = ${JSON.stringify(headers)};
 const __publicFiles = new Set(${JSON.stringify(publicFiles)});
 const __allowedOrigins = ${JSON.stringify(allowedOrigins)};
+const __expireTime = ${JSON.stringify(expireTime)};
 
 ${generateDevOriginCheckCode(config?.allowedDevOrigins)}
 
-// ── ReDoS-safe regex compilation (still needed for middleware matching) ──
-${generateSafeRegExpCode("modern")}
-
-// ── Path normalization ──────────────────────────────────────────────────
-${generateNormalizePathCode("modern")}
-${generateRouteMatchNormalizationCode("modern")}
-
-// ── Config pattern matching, redirects, rewrites, headers, CSRF validation,
-//    external URL proxy, cookie parsing, and request context are imported from
-//    config-matchers.ts and request-pipeline.ts (see import statements above).
-//    This eliminates ~250 lines of duplicated inline code and ensures the
-//    single-pass tokenizer in config-matchers.ts is used consistently
-//    (fixing the chained .replace() divergence flagged by CodeQL).
-
-/**
- * Build a request context from the live ALS HeadersContext, which reflects
- * any x-middleware-request-* header mutations applied by middleware.
- * Used for afterFiles and fallback rewrite has/missing evaluation — these
- * run after middleware in the App Router execution order.
- */
-function __buildPostMwRequestContext(request) {
-  const url = new URL(request.url);
-  const ctx = getHeadersContext();
-  if (!ctx) return requestContextFromRequest(request);
-  // ctx.cookies is a Map<string, string> (HeadersContext), but RequestContext
-  // requires a plain Record<string, string> for has/missing cookie evaluation
-  // (config-matchers.ts uses obj[key] not Map.get()). Convert here.
-  const cookiesRecord = Object.fromEntries(ctx.cookies);
-  return {
-    headers: ctx.headers,
-    cookies: cookiesRecord,
-    query: url.searchParams,
-    host: normalizeHost(ctx.headers.get("host"), url.hostname),
-  };
-}
-
 /**
  * Maximum server-action request body size.
  * Configurable via experimental.serverActions.bodySizeLimit in next.config.
@@ -1068,63 +318,6 @@ function __buildPostMwRequestContext(request) {
  */
 var __MAX_ACTION_BODY_SIZE = ${JSON.stringify(bodySizeLimit)};
 
-/**
- * Read a request body as text with a size limit.
- * Enforces the limit on the actual byte stream to prevent bypasses
- * via chunked transfer-encoding where Content-Length is absent or spoofed.
- */
-async function __readBodyWithLimit(request, maxBytes) {
-  if (!request.body) return "";
-  var reader = request.body.getReader();
-  var decoder = new TextDecoder();
-  var chunks = [];
-  var totalSize = 0;
-  for (;;) {
-    var result = await reader.read();
-    if (result.done) break;
-    totalSize += result.value.byteLength;
-    if (totalSize > maxBytes) {
-      reader.cancel();
-      throw new Error("Request body too large");
-    }
-    chunks.push(decoder.decode(result.value, { stream: true }));
-  }
-  chunks.push(decoder.decode());
-  return chunks.join("");
-}
-
-/**
- * Read a request body as FormData with a size limit.
- * Consumes the body stream with a byte counter and then parses the
- * collected bytes as multipart form data via the Response constructor.
- */
-async function __readFormDataWithLimit(request, maxBytes) {
-  if (!request.body) return new FormData();
-  var reader = request.body.getReader();
-  var chunks = [];
-  var totalSize = 0;
-  for (;;) {
-    var result = await reader.read();
-    if (result.done) break;
-    totalSize += result.value.byteLength;
-    if (totalSize > maxBytes) {
-      reader.cancel();
-      throw new Error("Request body too large");
-    }
-    chunks.push(result.value);
-  }
-  // Reconstruct a Response with the original Content-Type so that
-  // the FormData parser can handle multipart boundaries correctly.
-  var combined = new Uint8Array(totalSize);
-  var offset = 0;
-  for (var chunk of chunks) {
-    combined.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  var contentType = request.headers.get("content-type") || "";
-  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.
@@ -1134,1411 +327,336 @@ export const generateStaticParamsMap = {
 // 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")}
+${generateStaticParamsEntries.join("\n")}
+};${loadPrerenderPagesRoutesCode}
+const rootParamNamesMap = {
+${routes.filter((r) => r.isDynamic && r.pagePath && r.rootParamNames && r.rootParamNames.length > 0).map((r) => `  ${JSON.stringify(r.pattern)}: ${JSON.stringify(r.rootParamNames)},`).join("\n")}
 };
 
-export default async function handler(request, ctx) {
-  ${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().
-  const headersCtx = headersContextFromRequest(request);
-  const __uCtx = _createUnifiedCtx({
-    headersContext: headersCtx,
-    executionContext: ctx ?? _getRequestExecutionContext() ?? null,
-    unstableCacheRevalidation: "background",
-  });
-  return _runWithUnifiedCtx(__uCtx, async () => {
-    _ensureFetchPatch();
-    const __reqCtx = requestContextFromRequest(request);
-    // Per-request container for middleware state. Passed into
-    // _handleRequest which fills in .headers and .status;
-    // avoids module-level variables that race on Workers.
-    const _mwCtx = { headers: null, requestHeaders: null, status: null };
-    let response;
-    try {
-      response = await _handleRequest(request, __reqCtx, _mwCtx);
-    } catch (err) {
-      // Dev only: embed err.cause chain into err.message/err.stack so Vite's
-      // dev-server "Internal server error:" logger (which builds output from
-      // message + stack only) reveals the underlying root cause (ECONNREFUSED,
-      // role missing, workerd socket error, etc.) instead of dropping it.
-      // Skipped in production because Node's util.inspect / workerd's logger
-      // already render .cause natively, so flattening would double-print it.
-      // NODE_ENV is build-time-replaced by Vite, so the prod bundle compiles
-      // this branch out entirely.
-      if (process.env.NODE_ENV !== "production") {
-        __flattenErrorCauses(err);
-      }
-      throw err;
-    }
-    // Apply custom headers from next.config.js to non-redirect responses.
-    // Skip redirects (3xx) because Response.redirect() creates immutable headers,
-    // and Next.js doesn't apply custom headers to redirects anyway.
-    if (response && response.headers && !(response.status >= 300 && response.status < 400)) {
-      if (__configHeaders.length) {
-        const url = new URL(request.url);
-        let pathname;
-        try { pathname = __normalizePath(__normalizePathnameForRouteMatch(url.pathname)); } catch { pathname = url.pathname; }
-        ${bp ? `if (pathname.startsWith(${JSON.stringify(bp)})) pathname = pathname.slice(${JSON.stringify(bp)}.length) || "/";` : ""}
-        const extraHeaders = matchHeaders(pathname, __configHeaders, __reqCtx);
-        for (const h of extraHeaders) {
-          // Use append() for headers where multiple values must coexist
-          // (Vary, Set-Cookie). Using set() on these would destroy
-          // existing values like "Vary: RSC, Accept" which are critical
-          // for correct CDN caching behavior.
-          const lk = h.key.toLowerCase();
-          if (lk === "vary" || lk === "set-cookie") {
-            response.headers.append(h.key, h.value);
-          } else if (!response.headers.has(lk)) {
-            // Middleware headers take precedence: skip config keys already
-            // set by middleware so middleware headers always win.
-            response.headers.set(h.key, h.value);
-          }
-        }
-      }
-    }
-    return response;
-  });
-}
-
-async function _handleRequest(request, __reqCtx, _mwCtx) {
-  const __reqStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
-  // __reqStart is included in the timing header so the Node logging middleware
-  // can compute true compile time as: handlerStart - middlewareStart.
-  // Format: "handlerStart,compileMs,renderMs" - all as integers (ms). Dev-only.
-  const url = new URL(request.url);
-
-  // ── Cross-origin request protection (dev only) ─────────────────────
-  // Block requests from non-localhost origins to prevent data exfiltration.
-  // Skipped in production — Vite replaces NODE_ENV at build time.
-  if (process.env.NODE_ENV !== "production") {
-    const __originBlock = __validateDevRequestOrigin(request);
-    if (__originBlock) return __originBlock;
-  }
-
-  // Guard against protocol-relative URL open redirects (see request-pipeline.ts).
-  const __protoGuard = guardProtocolRelativeUrl(url.pathname);
-  if (__protoGuard) return __protoGuard;
-
-  // Decode percent-encoding segment-wise and normalize pathname to canonical form.
-  // This preserves encoded path delimiters like %2F within a single segment.
-  // __normalizePath collapses //foo///bar → /foo/bar, resolves . and .. segments.
-  let decodedUrlPathname;
-  try { decodedUrlPathname = __normalizePathnameForRouteMatchStrict(url.pathname); } catch (e) {
-    return new Response("Bad Request", { status: 400 });
-  }
-  let pathname = __normalizePath(decodedUrlPathname);
-
-  ${bp ? `
-  if (!hasBasePath(pathname, __basePath) && !pathname.startsWith("/__vinext/")) {
-    return new Response("Not Found", { status: 404 });
-  }
-  // 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);
-  if (__tsRedirect) return __tsRedirect;
-
-  // ── Apply redirects from next.config.js ───────────────────────────────
-  if (__configRedirects.length) {
-    // Strip .rsc suffix before matching redirect rules - RSC (client-side nav) requests
-    // arrive as /some/path.rsc but redirect patterns are defined without it (e.g.
-    // /some/path). Without this, soft-nav fetches bypass all config redirects.
-    const __redirPathname = pathname.endsWith(".rsc") ? pathname.slice(0, -4) : pathname;
-    const __redir = matchRedirect(__redirPathname, __configRedirects, __reqCtx);
-    if (__redir) {
-      const __redirDest = sanitizeDestination(
-        __basePath &&
-          !isExternalUrl(__redir.destination) &&
-          !hasBasePath(__redir.destination, __basePath)
-          ? __basePath + __redir.destination
-          : __redir.destination
-      );
-      return new Response(null, {
-        status: __redir.permanent ? 308 : 307,
-        headers: { Location: __redirDest },
-      });
-    }
-  }
-
-  const isRscRequest = pathname.endsWith(".rsc") || request.headers.get("accept")?.includes("text/x-component");
-  // Read mounted-slots header once at the handler scope and thread it through
-  // every buildPageElements call site. Previously both the handler and
-  // buildPageElements read and normalized it independently, which invited
-  // silent drift if a future refactor changed only one path.
-  const __mountedSlotsHeader = __normalizeMountedSlotsHeader(
-    request.headers.get("x-vinext-mounted-slots"),
-  );
-  const interceptionContextHeader = request.headers.get("X-Vinext-Interception-Context")?.replaceAll("\0", "") || null;
-  let cleanPathname = pathname.replace(/\\.rsc$/, "");
-
-  // Middleware response headers and custom rewrite status are stored in
-  // _mwCtx (per-request container) so handler() can merge them into
-  // every response path without module-level state that races on Workers.
-
-  ${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
-  const _isProxy = ${JSON.stringify(isProxyFile(middlewarePath))};
-  const middlewareFn = _isProxy
-    ? (middlewareModule.proxy ?? middlewareModule.default)
-    : (middlewareModule.middleware ?? middlewareModule.default);
-  if (typeof middlewareFn !== "function") {
-    const _fileType = _isProxy ? "Proxy" : "Middleware";
-    const _expectedExport = _isProxy ? "proxy" : "middleware";
-    throw new Error("The " + _fileType + " file must export a function named \`" + _expectedExport + "\` or a \`default\` function.");
-  }
-  const middlewareMatcher = middlewareModule.config?.matcher;
-  if (matchesMiddleware(cleanPathname, middlewareMatcher, request, __i18nConfig)) {
-    try {
-      // Wrap in NextRequest so middleware gets .nextUrl, .cookies, .geo, .ip, etc.
-       // Always construct a new Request with the fully decoded + normalized pathname
-       // so middleware and the router see the same canonical path.
-      const mwUrl = new URL(request.url);
-      mwUrl.pathname = cleanPathname;
-      const mwRequest = new Request(mwUrl, request);
-      const __mwNextConfig = (__basePath || __i18nConfig) ? { basePath: __basePath, i18n: __i18nConfig ?? undefined } : undefined;
-      const nextRequest = mwRequest instanceof NextRequest ? mwRequest : new NextRequest(mwRequest, __mwNextConfig ? { nextConfig: __mwNextConfig } : undefined);
-      const mwFetchEvent = new NextFetchEvent({ page: cleanPathname });
-      let mwResponse;
-      try {
-        mwResponse = await middlewareFn(nextRequest, mwFetchEvent);
-      } finally {
-        const _mwWaitUntil = mwFetchEvent.drainWaitUntil();
-        const _mwExecCtx = _getRequestExecutionContext();
-        if (_mwExecCtx && typeof _mwExecCtx.waitUntil === "function") { _mwExecCtx.waitUntil(_mwWaitUntil); }
-      }
-      if (mwResponse) {
-        // Check for x-middleware-next (continue)
-        if (mwResponse.headers.get("x-middleware-next") === "1") {
-          // Middleware wants to continue — collect all headers except the two
-          // control headers we've already consumed.  x-middleware-request-*
-          // headers are kept so applyMiddlewareRequestHeaders() can unpack them;
-          // the blanket strip loop after that call removes every remaining
-          // x-middleware-* header before the set is merged into the response.
-           _mwCtx.headers = new Headers();
-          for (const [key, value] of mwResponse.headers) {
-            if (key !== "x-middleware-next" && key !== "x-middleware-rewrite") {
-              _mwCtx.headers.append(key, value);
-            }
-          }
-        } else {
-          // Check for redirect
-          if (mwResponse.status >= 300 && mwResponse.status < 400) {
-            return mwResponse;
-          }
-          // Check for rewrite
-          const rewriteUrl = mwResponse.headers.get("x-middleware-rewrite");
-          if (rewriteUrl) {
-            const rewriteParsed = new URL(rewriteUrl, request.url);
-            cleanPathname = rewriteParsed.pathname;
-            // Carry over query params from the rewrite URL so that
-            // searchParams props, useSearchParams(), and navigation context
-            // reflect the rewrite destination, not the original request.
-            url.search = rewriteParsed.search;
-            // Capture custom status code from rewrite (e.g. NextResponse.rewrite(url, { status: 403 }))
-            if (mwResponse.status !== 200) {
-              _mwCtx.status = mwResponse.status;
-            }
-            // Also save any other headers from the rewrite response
-            _mwCtx.headers = new Headers();
-            for (const [key, value] of mwResponse.headers) {
-              if (key !== "x-middleware-next" && key !== "x-middleware-rewrite") {
-                _mwCtx.headers.append(key, value);
-              }
-            }
-          } else {
-            // Middleware returned a custom response
-            return mwResponse;
-          }
-        }
-      }
-    } catch (err) {
-      console.error("[vinext] Middleware error:", err);
-      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
-  // request headers. Strip ALL x-middleware-* headers from the set that will
-  // be merged into the outgoing HTTP response — this prefix is reserved for
-  // internal routing signals and must never reach clients.
-  if (_mwCtx.headers) {
-    // Preserve the pre-strip header set so route handlers can reconstruct
-    // a request object with middleware header overrides applied.
-    _mwCtx.requestHeaders = new Headers(_mwCtx.headers);
-    applyMiddlewareRequestHeaders(_mwCtx.headers);
-    processMiddlewareHeaders(_mwCtx.headers);
-  }
-  ` : ""}
-
-  const _scriptNonce = __getScriptNonceFromHeaderSources(request.headers, _mwCtx.headers);
-
-  // Build post-middleware request context for afterFiles/fallback rewrites.
-  // These run after middleware in the App Router execution order and should
-  // evaluate has/missing conditions against middleware-modified headers.
-  // When no middleware is present, this falls back to requestContextFromRequest.
-  const __postMwReqCtx = __buildPostMwRequestContext(request);
-
-  // ── Apply beforeFiles rewrites from next.config.js ────────────────────
-  // In App Router execution order, beforeFiles runs after middleware so that
-  // has/missing conditions can evaluate against middleware-modified headers.
-  if (__configRewrites.beforeFiles && __configRewrites.beforeFiles.length) {
-    const __rewritten = matchRewrite(cleanPathname, __configRewrites.beforeFiles, __postMwReqCtx);
-    if (__rewritten) {
-      if (isExternalUrl(__rewritten)) {
-        setHeadersContext(null);
-        setNavigationContext(null);
-        return proxyExternalRequest(request, __rewritten);
-      }
-      cleanPathname = __rewritten;
-    }
-  }
-
-  // ── Image optimization passthrough (dev mode — no transformation) ───────
-  if (cleanPathname === "/_vinext/image") {
-    const __imgResult = validateImageUrl(url.searchParams.get("url"), request.url);
-    if (__imgResult instanceof Response) return __imgResult;
-    // In dev, redirect to the original asset URL so Vite's static serving handles it.
-    return Response.redirect(new URL(__imgResult, url.origin).href, 302);
-  }
-
-  // Handle metadata routes (sitemap.xml, robots.txt, manifest.webmanifest, etc.)
-  for (const metaRoute of metadataRoutes) {
-    // generateSitemaps() support — paginated sitemaps at /{prefix}/sitemap/{id}.xml
-    // When a sitemap module exports generateSitemaps, the base URL (e.g. /products/sitemap.xml)
-    // is no longer served. Instead, individual sitemaps are served at /products/sitemap/{id}.xml.
-    if (
-      metaRoute.type === "sitemap" &&
-      metaRoute.isDynamic &&
-      typeof metaRoute.module.generateSitemaps === "function"
-    ) {
-      const sitemapPrefix = metaRoute.servedUrl.slice(0, -4); // strip ".xml"
-      // Match exactly /{prefix}/{id}.xml — one segment only (no slashes in id)
-      if (cleanPathname.startsWith(sitemapPrefix + "/") && cleanPathname.endsWith(".xml")) {
-        const rawId = cleanPathname.slice(sitemapPrefix.length + 1, -4);
-        if (rawId.includes("/")) continue; // multi-segment — not a paginated sitemap
-        const sitemaps = await metaRoute.module.generateSitemaps();
-        const matched = sitemaps.find(function(s) { return String(s.id) === rawId; });
-        if (!matched) return new Response("Not Found", { status: 404 });
-        // Pass the original typed id from generateSitemaps() so numeric IDs stay numeric.
-        // TODO: wrap with makeThenableParams-style Promise when upgrading to Next.js 16
-        // full-Promise param semantics (id becomes Promise<string> in v16).
-        const result = await metaRoute.module.default({ id: matched.id });
-        if (result instanceof Response) return result;
-        return new Response(sitemapToXml(result), {
-          headers: { "Content-Type": metaRoute.contentType },
-        });
-      }
-      // Skip — the base servedUrl is not served when generateSitemaps exists
-      continue;
-    }
-    // Match metadata route — use pattern matching for dynamic segments,
-    // strict equality for static paths.
-    var _metaParams = null;
-    if (metaRoute.patternParts) {
-      var _metaUrlParts = cleanPathname.split("/").filter(Boolean);
-      _metaParams = matchPattern(_metaUrlParts, metaRoute.patternParts);
-      if (!_metaParams) continue;
-    } else if (cleanPathname !== metaRoute.servedUrl) {
-      continue;
-    }
-    if (metaRoute.isDynamic) {
-      // Dynamic metadata route — call the default export and serialize
-      const metaFn = metaRoute.module.default;
-      if (typeof metaFn === "function") {
-        const result = await metaFn({ params: makeThenableParams(_metaParams || {}) });
-        let body;
-        // If it's already a Response (e.g., ImageResponse), return directly
-        if (result instanceof Response) return result;
-        // Serialize based on type
-        if (metaRoute.type === "sitemap") body = sitemapToXml(result);
-        else if (metaRoute.type === "robots") body = robotsToText(result);
-        else if (metaRoute.type === "manifest") body = manifestToJson(result);
-        else body = JSON.stringify(result);
-        return new Response(body, {
-          headers: { "Content-Type": metaRoute.contentType },
-        });
-      }
-    } else {
-      // Static metadata file — decode from embedded base64 data
-      try {
-        const binary = atob(metaRoute.fileDataBase64);
-        const bytes = new Uint8Array(binary.length);
-        for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-        return new Response(bytes, {
-          headers: {
-            "Content-Type": metaRoute.contentType,
-            "Cache-Control": "public, max-age=0, must-revalidate",
-          },
-        });
-      } catch {
-        return new Response("Not Found", { status: 404 });
-      }
-    }
-  }
-
-  // Serve public/ files as filesystem routes after middleware and before
-  // afterFiles/fallback rewrites, matching Next.js routing semantics.
-  if (
-    (request.method === "GET" || request.method === "HEAD") &&
-    !pathname.endsWith(".rsc") &&
-    __publicFiles.has(cleanPathname)
-  ) {
-    setHeadersContext(null);
-    setNavigationContext(null);
-    return __createStaticFileSignal(cleanPathname, _mwCtx);
-  }
-
-  // Set navigation context for Server Components.
-  // Note: Headers context is already set by runWithRequestContext in the handler wrapper.
-  setNavigationContext({
-    pathname: cleanPathname,
-    searchParams: url.searchParams,
-    params: {},
-  });
-
-  // Handle server action POST requests
-  const actionId = request.headers.get("x-rsc-action") ?? request.headers.get("next-action");
-  const actionContentType = request.headers.get("content-type") || "";
-  const progressiveActionResponse = await __handleProgressiveServerActionRequest({
-    actionId,
-    allowedOrigins: __allowedOrigins,
+export default __createAppRscHandler({
+  basePath: __basePath,
+  clearRequestContext() {
+    __clearRequestContext();
+  },
+  configHeaders: __configHeaders,
+  configRedirects: __configRedirects,
+  configRewrites: __configRewrites,
+  dispatchMatchedPage({
     cleanPathname,
-    clearRequestContext() {
-      setHeadersContext(null);
-      setNavigationContext(null);
-    },
-    contentType: actionContentType,
-    decodeAction,
-    getAndClearPendingCookies,
-    getDraftModeCookieHeader,
-    maxActionBodySize: __MAX_ACTION_BODY_SIZE,
-    middlewareHeaders: _mwCtx.headers,
-    readFormDataWithLimit: __readFormDataWithLimit,
-    reportRequestError: _reportRequestError,
-    request,
-    setHeadersAccessPhase,
-  });
-  if (progressiveActionResponse) return progressiveActionResponse;
-
-  if (request.method === "POST" && actionId) {
-    // ── CSRF protection ─────────────────────────────────────────────────
-    // Verify that the Origin header matches the Host header to prevent
-    // cross-site request forgery, matching Next.js server action behavior.
-    const csrfResponse = validateCsrfOrigin(request, __allowedOrigins);
-    if (csrfResponse) return csrfResponse;
-
-    // ── Body size limit ─────────────────────────────────────────────────
-    // Reject payloads larger than the configured limit.
-    // Check Content-Length as a fast path, then enforce on the actual
-    // stream to prevent bypasses via chunked transfer-encoding.
-    const contentLength = parseInt(request.headers.get("content-length") || "0", 10);
-    if (contentLength > __MAX_ACTION_BODY_SIZE) {
-      setHeadersContext(null);
-      setNavigationContext(null);
-      return new Response("Payload Too Large", { status: 413 });
-    }
-
-    try {
-      let body;
-      try {
-        body = actionContentType.startsWith("multipart/form-data")
-          ? await __readFormDataWithLimit(request, __MAX_ACTION_BODY_SIZE)
-          : await __readBodyWithLimit(request, __MAX_ACTION_BODY_SIZE);
-      } catch (sizeErr) {
-        if (sizeErr && sizeErr.message === "Request body too large") {
-          setHeadersContext(null);
-          setNavigationContext(null);
-          return new Response("Payload Too Large", { status: 413 });
-        }
-        throw sizeErr;
-      }
-      const payloadResponse = await validateServerActionPayload(body);
-      if (payloadResponse) {
-        setHeadersContext(null);
-        setNavigationContext(null);
-        return payloadResponse;
-      }
-      const temporaryReferences = createTemporaryReferenceSet();
-      const args = await decodeReply(body, { temporaryReferences });
-      const action = await loadServerAction(actionId);
-      let returnValue;
-      let actionRedirect = null;
-      const previousHeadersPhase = setHeadersAccessPhase("action");
-      try {
-        try {
-          const data = await action.apply(null, args);
-          returnValue = { ok: true, data };
-        } catch (e) {
-          // Detect redirect() / permanentRedirect() called inside the action.
-          // These throw errors with digest "NEXT_REDIRECT;replace;url[;status]".
-          // The URL is encodeURIComponent-encoded to prevent semicolons in the URL
-          // from corrupting the delimiter-based digest format.
-          if (e && typeof e === "object" && "digest" in e) {
-            const digest = String(e.digest);
-            if (digest.startsWith("NEXT_REDIRECT;")) {
-              const parts = digest.split(";");
-              actionRedirect = {
-                url: decodeURIComponent(parts[2]),
-                type: parts[1] || "push",          // "push" or "replace"
-                status: parts[3] ? parseInt(parts[3], 10) : 307,
-              };
-              returnValue = { ok: true, data: undefined };
-            } else if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;")) {
-              // notFound() / forbidden() / unauthorized() in action — package as error
-              returnValue = { ok: false, data: e };
-            } else {
-              // Non-navigation digest error — sanitize in production to avoid
-              // leaking internal details (connection strings, paths, etc.)
-              console.error("[vinext] Server action error:", e);
-              returnValue = { ok: false, data: __sanitizeErrorForClient(e) };
-            }
-          } else {
-            // Unhandled error — sanitize in production to avoid leaking
-            // internal details (database errors, file paths, stack traces, etc.)
-            console.error("[vinext] Server action error:", e);
-            returnValue = { ok: false, data: __sanitizeErrorForClient(e) };
-          }
-        }
-      } finally {
-        setHeadersAccessPhase(previousHeadersPhase);
-      }
-
-      // If the action called redirect(), signal the client to navigate.
-      // We can't use a real HTTP redirect (the fetch would follow it automatically
-      // and receive a page HTML instead of RSC stream). Instead, we return a 200
-      // with x-action-redirect header that the client entry detects and handles.
-      if (actionRedirect) {
-        const actionPendingCookies = getAndClearPendingCookies();
-        const actionDraftCookie = getDraftModeCookieHeader();
-        setHeadersContext(null);
-        setNavigationContext(null);
-        const redirectHeaders = new Headers({
-          "Content-Type": "text/x-component; charset=utf-8",
-          "Vary": "RSC, Accept",
-        });
-        __mergeMiddlewareResponseHeaders(redirectHeaders, _mwCtx.headers);
-        redirectHeaders.set("x-action-redirect", actionRedirect.url);
-        redirectHeaders.set("x-action-redirect-type", actionRedirect.type);
-        redirectHeaders.set("x-action-redirect-status", String(actionRedirect.status));
-        for (const cookie of actionPendingCookies) {
-          redirectHeaders.append("Set-Cookie", cookie);
-        }
-        if (actionDraftCookie) redirectHeaders.append("Set-Cookie", actionDraftCookie);
-        // Send an empty RSC-like body (client will navigate instead of parsing)
-        return new Response("", { status: 200, headers: redirectHeaders });
-      }
-
-      // After the action, re-render the current page so the client
-      // gets an updated React tree reflecting any mutations.
-      //
-      // When the original request came from inside an intercepted modal
-      // (X-Vinext-Interception-Context present + source route still
-      // matches), rebuild the intercepted tree — otherwise the modal would
-      // unmount and the direct route would render in its place. Mirrors
-      // the interception resolution used by the GET path.
-      const match = matchRoute(cleanPathname);
-      let element;
-      let errorPattern = match ? match.route.pattern : cleanPathname;
-      if (match) {
-        const { route: actionRoute, params: actionParams } = match;
-        const __actionRerenderTarget = __resolveAppPageActionRerenderTarget({
-          cleanPathname,
-          currentParams: actionParams,
-          currentRoute: actionRoute,
-          findIntercept(pathname) {
-            return findIntercept(pathname, interceptionContextHeader);
-          },
-          getRouteParamNames(sourceRoute) {
-            return sourceRoute.params;
-          },
-          getSourceRoute(sourceRouteIndex) {
-            return routes[sourceRouteIndex];
-          },
-          isRscRequest,
-          toInterceptOpts(intercept) {
-            return {
-              interceptionContext: interceptionContextHeader,
-              interceptLayouts: intercept.interceptLayouts,
-              interceptSlotKey: intercept.slotKey,
-              interceptPage: intercept.page,
-              interceptParams: intercept.matchedParams,
-            };
-          },
-        });
-
-        setNavigationContext({
-          pathname: cleanPathname,
-          searchParams: url.searchParams,
-          params: __actionRerenderTarget.navigationParams,
-        });
-        element = buildPageElements(
-          __actionRerenderTarget.route,
-          __actionRerenderTarget.params,
-          cleanPathname,
-          {
-            opts: __actionRerenderTarget.interceptOpts,
-            searchParams: url.searchParams,
-            isRscRequest,
-            request,
-            mountedSlotsHeader: __mountedSlotsHeader,
-          },
-        );
-        errorPattern = __actionRerenderTarget.route.pattern;
-      } else {
-        const _actionRouteId = __createAppPayloadRouteId(cleanPathname, null);
-        element = {
-          [__APP_INTERCEPTION_CONTEXT_KEY]: null,
-          __route: _actionRouteId,
-          __rootLayout: null,
-          [_actionRouteId]: createElement("div", null, "Page not found"),
-        };
-      }
-
-      const onRenderError = createRscOnErrorHandler(
-        request,
-        cleanPathname,
-        errorPattern,
-      );
-      const rscStream = renderToReadableStream(
-        { root: element, returnValue },
-        { temporaryReferences, onError: onRenderError },
-      );
-
-      // Collect cookies set during the action synchronously (before stream is consumed).
-      // Do NOT clear headers/navigation context here — the RSC stream is consumed lazily
-      // by the client, and async server components that run during consumption need the
-      // context to still be live. The AsyncLocalStorage scope from runWithRequestContext
-      // handles cleanup naturally when all async continuations complete.
-      const actionPendingCookies = getAndClearPendingCookies();
-      const actionDraftCookie = getDraftModeCookieHeader();
-
-      const actionHeaders = new Headers({
-        "Content-Type": "text/x-component; charset=utf-8",
-        "Vary": "RSC, Accept",
-      });
-      __mergeMiddlewareResponseHeaders(actionHeaders, _mwCtx.headers);
-      const actionResponse = new Response(rscStream, {
-        status: _mwCtx.status ?? 200,
-        headers: actionHeaders,
-      });
-      if (actionPendingCookies.length > 0 || actionDraftCookie) {
-        for (const cookie of actionPendingCookies) {
-          actionResponse.headers.append("Set-Cookie", cookie);
-        }
-        if (actionDraftCookie) actionResponse.headers.append("Set-Cookie", actionDraftCookie);
-      }
-      return actionResponse;
-    } catch (err) {
-      getAndClearPendingCookies(); // Clear pending cookies on error
-      console.error("[vinext] Server action error:", err);
-      _reportRequestError(
-        err instanceof Error ? err : new Error(String(err)),
-        { path: cleanPathname, method: request.method, headers: Object.fromEntries(request.headers.entries()) },
-        { routerKind: "App Router", routePath: cleanPathname, routeType: "action" },
-      );
-      setHeadersContext(null);
-      setNavigationContext(null);
-      return new Response(
-        process.env.NODE_ENV === "production"
-          ? "Internal Server Error"
-          : "Server action failed: " + (err && err.message ? err.message : String(err)),
-        { status: 500 },
-      );
-    }
-  }
-
-  // ── Apply afterFiles rewrites from next.config.js ──────────────────────
-  if (__configRewrites.afterFiles && __configRewrites.afterFiles.length) {
-    const __afterRewritten = matchRewrite(cleanPathname, __configRewrites.afterFiles, __postMwReqCtx);
-    if (__afterRewritten) {
-      if (isExternalUrl(__afterRewritten)) {
-        setHeadersContext(null);
-        setNavigationContext(null);
-        return proxyExternalRequest(request, __afterRewritten);
-      }
-      cleanPathname = __afterRewritten;
-    }
-  }
-
-  let match = matchRoute(cleanPathname);
-
-  // ── Fallback rewrites from next.config.js (if no route matched) ───────
-  if (!match && __configRewrites.fallback && __configRewrites.fallback.length) {
-    const __fallbackRewritten = matchRewrite(cleanPathname, __configRewrites.fallback, __postMwReqCtx);
-    if (__fallbackRewritten) {
-      if (isExternalUrl(__fallbackRewritten)) {
-        setHeadersContext(null);
-        setNavigationContext(null);
-        return proxyExternalRequest(request, __fallbackRewritten);
-      }
-      cleanPathname = __fallbackRewritten;
-      match = matchRoute(cleanPathname);
-    }
-  }
-
-  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 __pagesRequestHeaders = _mwCtx.requestHeaders
-          ? __buildRequestHeadersFromMiddlewareResponse(request.headers, _mwCtx.requestHeaders)
-          : null;
-        const __pagesRequest = __pagesRequestHeaders
-          ? new Request(request.url, { method: request.method, headers: __pagesRequestHeaders })
-          : request;
-        // Use segment-wise decoding to preserve encoded path delimiters (%2F).
-        // decodeURIComponent would turn /admin%2Fpanel into /admin/panel,
-        // changing the path structure and bypassing middleware matchers.
-        // Ported from Next.js: packages/next/src/server/lib/router-utils/decode-path-params.ts
-        // https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/decode-path-params.ts
-        const __pagesRes = await __pagesEntry.renderPage(
-          __pagesRequest,
-          __decodePathParams(url.pathname) + (url.search || ""),
-          {},
-          undefined,
-          _mwCtx.requestHeaders,
-        );
-        // 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, undefined, _scriptNonce, _mwCtx);
-    if (notFoundResponse) return notFoundResponse;
-    setHeadersContext(null);
-    setNavigationContext(null);
-    const notFoundHeaders = new Headers();
-    __mergeMiddlewareResponseHeaders(notFoundHeaders, _mwCtx.headers);
-    return new Response("Not Found", { status: 404, headers: notFoundHeaders });
-  }
-
-  const { route, params } = match;
-  setCurrentFetchSoftTags(__pageCacheTags(cleanPathname, []));
-
-  // Update navigation context with matched params
-  setNavigationContext({
-    pathname: cleanPathname,
-    searchParams: url.searchParams,
+    handlerStart,
+    interceptionContext,
+    isRscRequest,
+    middlewareContext,
+    mountedSlotsHeader,
     params,
-  });
-
-  // Handle route.ts API handlers
-  if (route.routeHandler) {
-    const handler = route.routeHandler;
-    const method = request.method.toUpperCase();
-    const revalidateSeconds = __getAppRouteHandlerRevalidateSeconds(handler);
-    if (__hasAppRouteHandlerDefaultExport(handler) && 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.",
-      );
-    }
-
-    const {
-      allowHeaderForOptions,
-      handlerFn,
-      isAutoHead,
-      shouldAutoRespondToOptions,
-    } = __resolveAppRouteHandlerMethod(handler, method);
-
-    if (shouldAutoRespondToOptions) {
-      setHeadersContext(null);
-      setNavigationContext(null);
-      return __applyRouteHandlerMiddlewareContext(
-        new Response(null, {
-          status: 204,
-          headers: { "Allow": allowHeaderForOptions },
-        }),
-        _mwCtx,
-      );
-    }
-
-    // ISR cache read for route handlers (production only).
-    // Only GET/HEAD (auto-HEAD) with finite revalidate > 0 are ISR-eligible.
-    // Known-dynamic handlers skip the read entirely so stale cache entries
-    // from earlier requests do not replay once the process has learned they
-    // access request-specific data.
-    if (
-      __shouldReadAppRouteHandlerCache({
-        dynamicConfig: handler.dynamic,
-        handlerFn,
-        isAutoHead,
-        isKnownDynamic: __isKnownDynamicAppRoute(route.pattern),
-        isProduction: process.env.NODE_ENV === "production",
-        method,
-        revalidateSeconds,
-      })
-    ) {
-      const __cachedRouteResponse = await __readAppRouteHandlerCacheResponse({
-        basePath: __basePath,
-        buildPageCacheTags: __pageCacheTags,
-        cleanPathname,
-        clearRequestContext: function() {
-          setHeadersContext(null);
-          setNavigationContext(null);
-        },
-        consumeDynamicUsage,
-        getCollectedFetchTags,
-        handlerFn,
-        i18n: __i18nConfig,
-        isAutoHead,
-        isrDebug: __isrDebug,
-        isrGet: __isrGet,
-        isrRouteKey: __isrRouteKey,
-        isrSet: __isrSet,
-        markDynamicUsage,
-        middlewareContext: _mwCtx,
-        params,
-        requestUrl: request.url,
-        revalidateSearchParams: url.searchParams,
-        revalidateSeconds,
-        routePattern: route.pattern,
-        runInRevalidationContext: async function(renderFn) {
-          const __revalHeadCtx = { headers: new Headers(), cookies: new Map() };
-          const __revalUCtx = _createUnifiedCtx({
-            headersContext: __revalHeadCtx,
-            executionContext: _getRequestExecutionContext(),
-            unstableCacheRevalidation: "foreground",
-          });
-          await _runWithUnifiedCtx(__revalUCtx, async () => {
-            _ensureFetchPatch();
-            setCurrentFetchSoftTags(__pageCacheTags(cleanPathname, []));
-            await renderFn();
-          });
-        },
-        scheduleBackgroundRegeneration: __triggerBackgroundRegeneration,
-        setNavigationContext,
-      });
-      if (__cachedRouteResponse) {
-        return __cachedRouteResponse;
-      }
-    }
-
-    if (typeof handlerFn === "function") {
-      return __executeAppRouteHandler({
-        basePath: __basePath,
-        buildPageCacheTags: __pageCacheTags,
-        cleanPathname,
-        clearRequestContext: function() {
-          setHeadersContext(null);
-          setNavigationContext(null);
-        },
-        consumeDynamicUsage,
-        executionContext: _getRequestExecutionContext(),
-        getAndClearPendingCookies,
-        getCollectedFetchTags,
-        getDraftModeCookieHeader,
-        handler,
-        handlerFn,
-        i18n: __i18nConfig,
-        isAutoHead,
-        isProduction: process.env.NODE_ENV === "production",
-        isrDebug: __isrDebug,
-        isrRouteKey: __isrRouteKey,
-        isrSet: __isrSet,
-        markDynamicUsage,
-        method,
-        middlewareContext: _mwCtx,
-        middlewareRequestHeaders: _mwCtx.requestHeaders,
-        params: makeThenableParams(params),
-        reportRequestError: _reportRequestError,
-        request,
-        revalidateSeconds,
-        routePattern: route.pattern,
-        setHeadersAccessPhase,
-      });
-    }
-    setHeadersContext(null);
-    setNavigationContext(null);
-    return __applyRouteHandlerMiddlewareContext(
-      new Response(null, {
-        status: 405,
-      }),
-      _mwCtx,
-    );
-  }
-
-  // Build the component tree: layouts wrapping the page
-  const hasPageModule = !!route.page;
-  const PageComponent = route.page?.default;
-  if (hasPageModule && !PageComponent) {
-    setHeadersContext(null);
-    setNavigationContext(null);
-    return new Response("Page has no default export", { status: 500 });
-  }
-
-  // Read route segment config from page module exports
-  let revalidateSeconds = typeof route.page?.revalidate === "number" ? route.page.revalidate : null;
-  const dynamicConfig = route.page?.dynamic; // 'auto' | 'force-dynamic' | 'force-static' | 'error'
-  const dynamicParamsConfig = route.page?.dynamicParams; // true (default) | false
-  const isForceStatic = dynamicConfig === "force-static";
-  const isDynamicError = dynamicConfig === "error";
-
-  // force-static: replace headers/cookies context with empty values and
-  // clear searchParams so dynamic APIs return defaults instead of real data
-  if (isForceStatic) {
-    setHeadersContext({ headers: new Headers(), cookies: new Map() });
-    setNavigationContext({
-      pathname: cleanPathname,
-      searchParams: new URLSearchParams(),
-      params,
-    });
-  }
-
-  // dynamic = 'error': install an access error so request APIs fail with the
-  // static-generation message even for legacy sync property access.
-  if (isDynamicError) {
-    const errorMsg = 'Page with \`dynamic = "error"\` used a dynamic API. ' +
-      'This page was expected to be fully static, but headers(), cookies(), ' +
-      'or searchParams was accessed. Remove the dynamic API usage or change ' +
-      'the dynamic config to "auto" or "force-dynamic".';
-    setHeadersContext({
-      headers: new Headers(),
-      cookies: new Map(),
-      accessError: new Error(errorMsg),
+    request,
+    route,
+    scriptNonce,
+    searchParams,
+  }) {
+    const PageComponent = route.page?.default;
+    const __segmentConfig = __resolveAppPageSegmentConfig({
+      layouts: route.layouts,
+      page: route.page,
     });
-    setNavigationContext({
-      pathname: cleanPathname,
-      searchParams: new URLSearchParams(),
-      params,
+    const __generateStaticParams = __resolveAppPageGenerateStaticParamsSources({
+      layouts: route.layouts,
+      layoutTreePositions: route.layoutTreePositions,
+      page: route.page,
+      routeSegments: route.routeSegments,
     });
-  }
-
-  // force-dynamic: set no-store Cache-Control
-  const isForceDynamic = dynamicConfig === "force-dynamic";
-
-  // ── ISR cache read (production only) ─────────────────────────────────────
-  // Read from cache BEFORE generateStaticParams and all rendering work.
-  // This is the critical performance optimization: on a cache hit we skip
-  // ALL expensive work (generateStaticParams, buildPageElement, layout probe,
-  // page probe, renderToReadableStream, SSR). Both HTML and RSC requests
-  // (client-side navigation / prefetch) are served from cache.
-  //
-  // HTML and RSC are stored under separate keys (matching Next.js's .html/.rsc
-  // file layout) so each request type reads and writes independently — no races,
-  // no partial-entry sentinels, no read-before-write hacks needed.
-  //
-  // force-static and dynamic='error' are compatible with ISR — they control
-  // how dynamic APIs behave during rendering, not whether results are cached.
-  // Only force-dynamic truly bypasses the ISR cache.
-  if (
-    process.env.NODE_ENV === "production" &&
-    !isForceDynamic &&
-    (isRscRequest || !_scriptNonce) &&
-    revalidateSeconds !== null && revalidateSeconds > 0 && revalidateSeconds !== Infinity
-  ) {
-    const __cachedPageResponse = await __readAppPageCacheResponse({
+    const _asyncRouteParams = makeThenableParams(params);
+    return __dispatchAppPage({
+      buildPageElement(targetRoute, targetParams, targetOpts, targetSearchParams) {
+        return buildPageElements(targetRoute, targetParams, cleanPathname, {
+          opts: targetOpts,
+          searchParams: targetSearchParams,
+          isRscRequest,
+          request,
+          mountedSlotsHeader,
+        });
+      },
       cleanPathname,
-      clearRequestContext: function() {
-        setHeadersContext(null);
-        setNavigationContext(null);
+      clearRequestContext() {
+        __clearRequestContext();
       },
+      createRscOnErrorHandler(pathname, routePath) {
+        return createRscOnErrorHandler(request, pathname, routePath);
+      },
+      debugClassification: __classDebug,
+      dynamicConfig: __segmentConfig.dynamicConfig,
+      dynamicParamsConfig: __segmentConfig.dynamicParamsConfig,
+      fetchCache: __segmentConfig.fetchCache ?? null,
+      findIntercept(pathname) {
+        return findIntercept(pathname, interceptionContext);
+      },
+      generateStaticParams: __generateStaticParams,
+      getFontLinks: _getSSRFontLinks,
+      getFontPreloads: _getSSRFontPreloads,
+      getFontStyles: _getSSRFontStyles,
+      getNavigationContext: _getNavigationContext,
+      getSourceRoute(sourceRouteIndex) {
+        return routes[sourceRouteIndex];
+      },
+      hasGenerateStaticParams: __generateStaticParams.length > 0,
+      hasPageDefaultExport: !!PageComponent,
+      hasPageModule: !!route.page,
+      handlerStart,
+      interceptionContext,
+      expireSeconds: __expireTime,
+      isProduction: process.env.NODE_ENV === "production",
       isRscRequest,
       isrDebug: __isrDebug,
       isrGet: __isrGet,
       isrHtmlKey: __isrHtmlKey,
       isrRscKey: __isrRscKey,
       isrSet: __isrSet,
-      mountedSlotsHeader: __mountedSlotsHeader,
-      revalidateSeconds,
-      renderFreshPageForCache: async function() {
-        // Re-render the page to produce fresh HTML + RSC data for the cache
-        // Use an empty headers context for background regeneration — not the original
-        // user request — to prevent user-specific cookies/auth headers from leaking
-        // into content that is cached and served to all subsequent users.
-        const __revalHeadCtx = { headers: new Headers(), cookies: new Map() };
-        const __revalUCtx = _createUnifiedCtx({
-          headersContext: __revalHeadCtx,
-          executionContext: _getRequestExecutionContext(),
-          unstableCacheRevalidation: "foreground",
-        });
-        return _runWithUnifiedCtx(__revalUCtx, async () => {
-          _ensureFetchPatch();
-          setCurrentFetchSoftTags(__pageCacheTags(cleanPathname, []));
-          setNavigationContext({ pathname: cleanPathname, searchParams: new URLSearchParams(), params });
-          // Slot context (X-Vinext-Mounted-Slots) is inherited from the
-          // triggering request so the regen result is cached under the
-          // correct slot-variant key.
-          const __revalElement = await buildPageElements(
-            route,
+      loadSsrHandler() {
+        return import.meta.viteRsc.loadModule("ssr", "index");
+      },
+      middlewareContext,
+      mountedSlotsHeader,
+      params,
+      probeLayoutAt(li) {
+        const LayoutComp = route.layouts[li]?.default;
+        if (!LayoutComp) return null;
+        return LayoutComp({
+          params: makeThenableParams(__resolveAppPageSegmentParams(
+            route.routeSegments,
+            route.layoutTreePositions?.[li] ?? 0,
             params,
-            cleanPathname,
-            {
-              opts: undefined,
-              searchParams: new URLSearchParams(),
-              isRscRequest,
-              request,
-              mountedSlotsHeader: __mountedSlotsHeader,
-            },
-          );
-          const __revalOnError = createRscOnErrorHandler(request, cleanPathname, route.pattern);
-          const __revalRscStream = renderToReadableStream(__revalElement, { onError: __revalOnError });
-          const __revalRscCapture = __teeAppPageRscStreamForCapture(__revalRscStream, true);
-          const __revalFontData = { links: _getSSRFontLinks(), styles: _getSSRFontStyles(), preloads: _getSSRFontPreloads() };
-          const __revalSsrEntry = await import.meta.viteRsc.loadModule("ssr", "index");
-          const __revalHtmlStream = await __revalSsrEntry.handleSsr(
-            __revalRscCapture.responseStream,
-            _getNavigationContext(),
-            __revalFontData,
-          );
-          setHeadersContext(null);
-          setNavigationContext(null);
-          const __freshHtml = await __readAppPageTextStream(__revalHtmlStream);
-          const __freshRscData = await __revalRscCapture.capturedRscDataPromise;
-          const __pageTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
-          return { html: __freshHtml, rscData: __freshRscData, tags: __pageTags };
+          )),
+          children: null,
         });
       },
-      scheduleBackgroundRegeneration: __triggerBackgroundRegeneration,
+      probePage() {
+        if (!PageComponent) return null;
+        const _asyncSearchParams = makeThenableParams(
+          __collectAppPageSearchParams(searchParams).searchParamsObject,
+        );
+        return PageComponent({ params: _asyncRouteParams, searchParams: _asyncSearchParams });
+      },
+      renderErrorBoundaryPage(renderErr) {
+        return __fallbackRenderer.renderErrorBoundary(route, renderErr, isRscRequest, request, params, scriptNonce, middlewareContext);
+      },
+      renderHttpAccessFallbackPage(statusCode, opts, currentMiddlewareContext) {
+        return __fallbackRenderer.renderHttpAccessFallback(route, statusCode, isRscRequest, request, opts, scriptNonce, currentMiddlewareContext);
+      },
+      renderToReadableStream,
+      request,
+      revalidateSeconds: __segmentConfig.revalidateSeconds,
+      resolveRouteFetchCacheMode(targetRoute) {
+        return __resolveRouteFetchCacheMode(targetRoute);
+      },
+      rootForbiddenModule,
+      rootNotFoundModule,
+      rootUnauthorizedModule,
+      route,
+      runWithSuppressedHookWarning(probe) {
+        return suppressHookWarningAls.run(true, probe);
+      },
+      scheduleBackgroundRegeneration(key, renderFn, errorContext) {
+        __triggerBackgroundRegeneration(key, renderFn, errorContext);
+      },
+      scriptNonce,
+      searchParams,
+      setNavigationContext,
     });
-    if (__cachedPageResponse) {
-      return __cachedPageResponse;
-    }
-  }
-
-  // dynamicParams = false: only params from generateStaticParams are allowed.
-  // This runs AFTER the ISR cache read so that a cache hit skips this work entirely.
-  const __dynamicParamsResponse = await __validateAppPageDynamicParams({
-    clearRequestContext() {
-      setHeadersContext(null);
-      setNavigationContext(null);
-    },
-    enforceStaticParamsOnly: dynamicParamsConfig === false,
-    generateStaticParams: route.page?.generateStaticParams,
-    isDynamicRoute: route.isDynamic,
-    logGenerateStaticParamsError(err) {
-      console.error("[vinext] generateStaticParams error:", err);
-    },
+  },
+  dispatchMatchedRouteHandler({
+    cleanPathname,
+    middlewareContext,
     params,
-  });
-  if (__dynamicParamsResponse) {
-    return __dynamicParamsResponse;
-  }
-
-  // Check for intercepting routes on RSC requests (client-side navigation).
-  // If the target URL matches an intercepting route in a parallel slot,
-  // render the source route with the intercepting page in the slot.
-  const __interceptResult = await __resolveAppPageIntercept({
-    buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams) {
-      return buildPageElements(
-        interceptRoute,
-        interceptParams,
-        cleanPathname,
-        {
-          opts: interceptOpts,
-          searchParams: interceptSearchParams,
-          isRscRequest,
-          request,
-          mountedSlotsHeader: __mountedSlotsHeader,
-        },
-      );
-    },
+    request,
+    route,
+    searchParams,
+  }) {
+    return __dispatchAppRouteHandler({
+      basePath: __basePath,
+      cleanPathname,
+      clearRequestContext() {
+        __clearRequestContext();
+      },
+      i18n: __i18nConfig,
+      isrDebug: __isrDebug,
+      isrGet: __isrGet,
+      isrRouteKey: __isrRouteKey,
+      isrSet: __isrSet,
+      middlewareContext,
+      middlewareRequestHeaders: middlewareContext.requestHeaders,
+      params,
+      request,
+      route: {
+        pattern: route.pattern,
+        routeHandler: route.routeHandler,
+        routeSegments: route.routeSegments,
+      },
+      scheduleBackgroundRegeneration: __triggerBackgroundRegeneration,
+      searchParams,
+    });
+  },
+  ${instrumentationPath ? `ensureInstrumentation() {
+    return __ensureInstrumentationRegistered(_instrumentation);
+  },` : ""}
+  handleProgressiveActionRequest({
+    actionId,
     cleanPathname,
-    currentRoute: route,
-    findIntercept(pathname) {
-      return findIntercept(pathname, interceptionContextHeader);
-    },
-    getRouteParamNames(sourceRoute) {
-      return sourceRoute.params;
-    },
-    getSourceRoute(sourceRouteIndex) {
-      return routes[sourceRouteIndex];
-    },
-    isRscRequest,
-    renderInterceptResponse(sourceRoute, interceptElement) {
-      const interceptOnError = createRscOnErrorHandler(
-        request,
-        cleanPathname,
-        sourceRoute.pattern,
-      );
-      const interceptStream = renderToReadableStream(interceptElement, {
-        onError: interceptOnError,
-      });
-      // Do NOT clear headers/navigation context here — the RSC stream is consumed lazily
-      // by the client, and async server components that run during consumption need the
-      // context to still be live. The AsyncLocalStorage scope from runWithRequestContext
-      // handles cleanup naturally when all async continuations complete.
-      const interceptHeaders = new Headers({
-        "Content-Type": "text/x-component; charset=utf-8",
-        "Vary": "RSC, Accept",
-      });
-      __mergeMiddlewareResponseHeaders(interceptHeaders, _mwCtx.headers);
-      return new Response(interceptStream, {
-        status: _mwCtx.status ?? 200,
-        headers: interceptHeaders,
-      });
-    },
-    searchParams: url.searchParams,
-    setNavigationContext,
-    toInterceptOpts(intercept) {
-      return {
-        interceptionContext: interceptionContextHeader,
-        interceptLayouts: intercept.interceptLayouts,
-        interceptSlotKey: intercept.slotKey,
-        interceptPage: intercept.page,
-        interceptParams: intercept.matchedParams,
-      };
-    },
-  });
-  if (__interceptResult.response) {
-    return __interceptResult.response;
-  }
-  const interceptOpts = __interceptResult.interceptOpts;
-
-  const __pageBuildResult = await __buildAppPageElement({
-    buildPageElement() {
-      return buildPageElements(route, params, cleanPathname, {
-        opts: interceptOpts,
-        searchParams: url.searchParams,
-        isRscRequest,
-        request,
-        mountedSlotsHeader: __mountedSlotsHeader,
-      });
-    },
-    renderErrorBoundaryPage(buildErr) {
-      return renderErrorBoundaryPage(route, buildErr, isRscRequest, request, params, _scriptNonce, _mwCtx);
-    },
-    renderSpecialError(__buildSpecialError) {
-      return __buildAppPageSpecialErrorResponse({
-        clearRequestContext() {
-          setHeadersContext(null);
-          setNavigationContext(null);
-        },
-        middlewareContext: _mwCtx,
-        renderFallbackPage(statusCode) {
-          return renderHTTPAccessFallbackPage(
-            route,
-            statusCode,
-            isRscRequest,
-            request,
-            {
-              matchedParams: params,
-            },
-            _scriptNonce,
-            // buildAppPageSpecialErrorResponse merges _mwCtx onto this returned
-            // fallback response; keep this inner boundary render unmerged so
-            // additive headers like Set-Cookie and Vary are not duplicated.
-            null,
-          );
-        },
-        requestUrl: request.url,
-        specialError: __buildSpecialError,
-      });
-    },
-    resolveSpecialError: __resolveAppPageSpecialError,
-  });
-  if (__pageBuildResult.response) {
-    return __pageBuildResult.response;
-  }
-  const element = __pageBuildResult.element;
-
-  // Note: CSS is automatically injected by @vitejs/plugin-rsc's
-  // rscCssTransform — no manual loadCss() call needed.
-  const _hasLoadingBoundary = !!(route.loading && route.loading.default);
-  const _asyncLayoutParams = makeThenableParams(params);
-  return __renderAppPageLifecycle({
+    contentType,
+    middlewareContext,
+    request,
+  }) {
+    return __handleProgressiveServerActionRequest({
+      actionId,
+      allowedOrigins: __allowedOrigins,
+      cleanPathname,
+      clearRequestContext() {
+        __clearRequestContext();
+      },
+      contentType,
+      decodeAction,
+      getAndClearPendingCookies,
+      getDraftModeCookieHeader,
+      maxActionBodySize: __MAX_ACTION_BODY_SIZE,
+      middlewareHeaders: middlewareContext.headers,
+      readFormDataWithLimit: __readFormDataWithLimit,
+      reportRequestError: _reportRequestError,
+      request,
+      setHeadersAccessPhase,
+    });
+  },
+  handleServerActionRequest({
+    actionId,
     cleanPathname,
-    clearRequestContext() {
-      setHeadersContext(null);
-      setNavigationContext(null);
-    },
-    consumeDynamicUsage,
-    createRscOnErrorHandler(pathname, routePath) {
-      return createRscOnErrorHandler(request, pathname, routePath);
-    },
-    element,
-    getDraftModeCookieHeader,
-    getFontLinks: _getSSRFontLinks,
-    getFontPreloads: _getSSRFontPreloads,
-    getFontStyles: _getSSRFontStyles,
-    getNavigationContext: _getNavigationContext,
-    getPageTags() {
-      return __pageCacheTags(cleanPathname, getCollectedFetchTags());
-    },
-    getRequestCacheLife() {
-      return _consumeRequestScopedCacheLife();
-    },
-    handlerStart: __reqStart,
-    hasLoadingBoundary: _hasLoadingBoundary,
-    isDynamicError,
-    isForceDynamic,
-    isForceStatic,
-    isProduction: process.env.NODE_ENV === "production",
+    contentType,
+    interceptionContext,
     isRscRequest,
-    isrDebug: __isrDebug,
-    isrHtmlKey: __isrHtmlKey,
-    isrRscKey: __isrRscKey,
-    isrSet: __isrSet,
-    layoutCount: route.layouts?.length ?? 0,
-    loadSsrHandler() {
-      return import.meta.viteRsc.loadModule("ssr", "index");
-    },
-    middlewareContext: _mwCtx,
-    params,
-    probeLayoutAt(li) {
-      const LayoutComp = route.layouts[li]?.default;
-      if (!LayoutComp) return null;
-      return LayoutComp({ params: _asyncLayoutParams, children: null });
-    },
-    probePage() {
-      if (!PageComponent) return null;
-      const _probeSearchObj = {};
-      url.searchParams.forEach(function(v, k) {
-        if (k in _probeSearchObj) {
-          _probeSearchObj[k] = Array.isArray(_probeSearchObj[k])
-            ? _probeSearchObj[k].concat(v)
-            : [_probeSearchObj[k], v];
-        } else {
-          _probeSearchObj[k] = v;
-        }
-      });
-      const _asyncSearchParams = makeThenableParams(_probeSearchObj);
-      return PageComponent({ params: _asyncLayoutParams, searchParams: _asyncSearchParams });
-    },
-    classification: {
-      getLayoutId(index) {
-        const tp = route.layoutTreePositions?.[index] ?? 0;
-        return "layout:" + __createAppPageTreePath(route.routeSegments, tp);
+    middlewareContext,
+    mountedSlotsHeader,
+    request,
+    searchParams,
+  }) {
+    return __handleServerActionRscRequest({
+      actionId,
+      allowedOrigins: __allowedOrigins,
+      buildPageElement({
+        route: actionRoute,
+        params: actionParams,
+        cleanPathname: actionCleanPathname,
+        interceptOpts,
+        searchParams: actionSearchParams,
+        isRscRequest: actionIsRscRequest,
+        request: actionRequest,
+        mountedSlotsHeader: actionMountedSlotsHeader,
+      }) {
+        return buildPageElements(actionRoute, actionParams, actionCleanPathname, {
+          opts: interceptOpts,
+          searchParams: actionSearchParams,
+          isRscRequest: actionIsRscRequest,
+          request: actionRequest,
+          mountedSlotsHeader: actionMountedSlotsHeader,
+        });
       },
-      buildTimeClassifications: route.__buildTimeClassifications,
-      buildTimeReasons: route.__buildTimeReasons,
-      debugClassification: __classDebug,
-      async runWithIsolatedDynamicScope(fn) {
-        const priorDynamic = consumeDynamicUsage();
-        try {
-          const result = await fn();
-          const dynamicDetected = consumeDynamicUsage();
-          return { result, dynamicDetected };
-        } finally {
-          consumeDynamicUsage();
-          if (priorDynamic) markDynamicUsage();
-        }
+      cleanPathname,
+      clearRequestContext() {
+        __clearRequestContext();
       },
-    },
-    revalidateSeconds,
-    mountedSlotsHeader: __mountedSlotsHeader,
-    renderErrorBoundaryResponse(renderErr) {
-      return renderErrorBoundaryPage(route, renderErr, isRscRequest, request, params, _scriptNonce, _mwCtx);
-    },
-    async renderLayoutSpecialError(__layoutSpecialError, li) {
-      return __buildAppPageSpecialErrorResponse({
-        clearRequestContext() {
-          setHeadersContext(null);
-          setNavigationContext(null);
-        },
-        middlewareContext: _mwCtx,
-        renderFallbackPage(statusCode) {
-          // Find the not-found component from the parent level (the boundary that
-          // would catch this in Next.js). Walk up from the throwing layout to find
-          // the nearest not-found at a parent layout's directory.
-          let parentNotFound = null;
-          if (route.notFounds) {
-            for (let pi = li - 1; pi >= 0; pi--) {
-              if (route.notFounds[pi]?.default) {
-                parentNotFound = route.notFounds[pi].default;
-                break;
-              }
-            }
-          }
-          if (!parentNotFound) parentNotFound = ${rootNotFoundVar ? `${rootNotFoundVar}?.default` : "null"};
-          const parentLayouts = route.layouts.slice(0, li);
-          return renderHTTPAccessFallbackPage(
-            route,
-            statusCode,
-            isRscRequest,
-            request,
-            {
-              boundaryComponent: parentNotFound,
-              layouts: parentLayouts,
-              matchedParams: params,
-            },
-            _scriptNonce,
-            // buildAppPageSpecialErrorResponse merges _mwCtx onto this returned
-            // fallback response; keep this inner boundary render unmerged so
-            // additive headers like Set-Cookie and Vary are not duplicated.
-            null,
-          );
-        },
-        requestUrl: request.url,
-        specialError: __layoutSpecialError,
-      });
-    },
-    async renderPageSpecialError(specialError) {
-      return __buildAppPageSpecialErrorResponse({
-        clearRequestContext() {
-          setHeadersContext(null);
-          setNavigationContext(null);
-        },
-        middlewareContext: _mwCtx,
-        renderFallbackPage(statusCode) {
-          return renderHTTPAccessFallbackPage(
-            route,
-            statusCode,
-            isRscRequest,
-            request,
-            {
-              matchedParams: params,
-            },
-            _scriptNonce,
-            // buildAppPageSpecialErrorResponse merges _mwCtx onto this returned
-            // fallback response; keep this inner boundary render unmerged so
-            // additive headers like Set-Cookie and Vary are not duplicated.
-            null,
-          );
-        },
-        requestUrl: request.url,
-        specialError,
-      });
-    },
-    renderToReadableStream,
-    routeHasLocalBoundary: !!(route?.error?.default) || !!(route?.errors && route.errors.some(function(e) { return e?.default; })),
-    routePattern: route.pattern,
-    runWithSuppressedHookWarning(probe) {
-      // Run inside ALS context so the module-level console.error patch suppresses
-      // "Invalid hook call" only for this request's probe — concurrent requests
-      // each have their own ALS store and are unaffected.
-      return _suppressHookWarningAls.run(true, probe);
-    },
-    scriptNonce: _scriptNonce,
-    waitUntil(__cachePromise) {
-      _getRequestExecutionContext()?.waitUntil(__cachePromise);
-    },
-  });
-}
+      contentType,
+      createNotFoundElement(actionRouteId) {
+        return {
+          [__APP_INTERCEPTION_CONTEXT_KEY]: null,
+          __route: actionRouteId,
+          __rootLayout: null,
+          [actionRouteId]: createElement("div", null, "Page not found"),
+        };
+      },
+      createPayloadRouteId(pathnameToRender, currentInterceptionContext) {
+        return __createAppPayloadRouteId(pathnameToRender, currentInterceptionContext);
+      },
+      createRscOnErrorHandler(actionRequest, actionPathname, routePattern) {
+        return createRscOnErrorHandler(actionRequest, actionPathname, routePattern);
+      },
+      createTemporaryReferenceSet,
+      decodeReply,
+      findIntercept(pathnameToMatch) {
+        return findIntercept(pathnameToMatch, interceptionContext);
+      },
+      getAndClearPendingCookies,
+      getDraftModeCookieHeader,
+      getRouteParamNames(sourceRoute) {
+        return sourceRoute.params;
+      },
+      getSourceRoute(sourceRouteIndex) {
+        return routes[sourceRouteIndex];
+      },
+      isRscRequest,
+      loadServerAction,
+      matchRoute(pathnameToMatch) {
+        return matchRoute(pathnameToMatch);
+      },
+      maxActionBodySize: __MAX_ACTION_BODY_SIZE,
+      middlewareHeaders: middlewareContext.headers,
+      middlewareStatus: middlewareContext.status,
+      mountedSlotsHeader,
+      readBodyWithLimit: __readBodyWithLimit,
+      readFormDataWithLimit: __readFormDataWithLimit,
+      renderToReadableStream,
+      reportRequestError: _reportRequestError,
+      request,
+      sanitizeErrorForClient(error) {
+        return __sanitizeErrorForClient(error);
+      },
+      searchParams,
+      setHeadersAccessPhase,
+      setNavigationContext,
+      toInterceptOpts(intercept) {
+        return {
+          interceptionContext,
+          interceptLayouts: intercept.interceptLayouts,
+          interceptSlotKey: intercept.slotKey,
+          interceptPage: intercept.page,
+          interceptParams: intercept.matchedParams,
+        };
+      },
+    });
+  },
+  i18nConfig: __i18nConfig,
+  isMiddlewareProxy: ${JSON.stringify(middlewarePath ? isProxyFile(middlewarePath) : false)},
+  ${hasPagesDir ? `loadPrerenderPagesRoutes: __loadPrerenderPagesRoutes,` : ""}
+  makeThenableParams,
+  matchRoute,
+  metadataRoutes,
+  middlewareModule: ${middlewarePath ? "middlewareModule" : "null"},
+  publicFiles: __publicFiles,
+  renderNotFound({ isRscRequest, matchedParams, middlewareContext, request, route, scriptNonce }) {
+    return __fallbackRenderer.renderNotFound(route, isRscRequest, request, matchedParams, scriptNonce, middlewareContext);
+  },
+  ${hasPagesDir ? `async renderPagesFallback({ isRscRequest, middlewareContext, request, url }) {
+    if (isRscRequest) return null;
+
+    const __pagesEntry = await import.meta.viteRsc.loadModule("ssr", "index");
+    if (typeof __pagesEntry.renderPage !== "function") return null;
+
+    const __pagesRequestHeaders = middlewareContext.requestHeaders
+      ? __buildRequestHeadersFromMiddlewareResponse(request.headers, middlewareContext.requestHeaders)
+      : null;
+    const __pagesRequest = __pagesRequestHeaders
+      ? new Request(request.url, { method: request.method, headers: __pagesRequestHeaders })
+      : request;
+    const __pagesRes = await __pagesEntry.renderPage(
+      __pagesRequest,
+      __decodePathParams(url.pathname) + (url.search || ""),
+      {},
+      undefined,
+      middlewareContext.requestHeaders,
+    );
+    return __pagesRes.status !== 404 ? __pagesRes : null;
+  },` : ""}
+  rootParamNamesByPattern: rootParamNamesMap,
+  setNavigationContext,
+  staticParamsMap: generateStaticParamsMap,
+  trailingSlash: __trailingSlash,
+  validateDevRequestOrigin: __validateDevRequestOrigin,
+});
 
 if (import.meta.hot) {
   import.meta.hot.accept();