vinext 0.0.32 → 0.0.34

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

@@ -16,33 +16,17 @@ import { fileURLToPath } from "node:url";
 const configMatchersPath = fileURLToPath(new URL("../config/config-matchers.js", import.meta.url)).replace(/\\/g, "/");
 const requestPipelinePath = fileURLToPath(new URL("../server/request-pipeline.js", import.meta.url)).replace(/\\/g, "/");
 const requestContextShimPath = fileURLToPath(new URL("../shims/request-context.js", import.meta.url)).replace(/\\/g, "/");
+const appRouteHandlerRuntimePath = fileURLToPath(new URL("../server/app-route-handler-runtime.js", import.meta.url)).replace(/\\/g, "/");
+const appRouteHandlerPolicyPath = fileURLToPath(new URL("../server/app-route-handler-policy.js", import.meta.url)).replace(/\\/g, "/");
+const appRouteHandlerExecutionPath = fileURLToPath(new URL("../server/app-route-handler-execution.js", import.meta.url)).replace(/\\/g, "/");
+const appRouteHandlerCachePath = fileURLToPath(new URL("../server/app-route-handler-cache.js", import.meta.url)).replace(/\\/g, "/");
+const appPageCachePath = fileURLToPath(new URL("../server/app-page-cache.js", import.meta.url)).replace(/\\/g, "/");
+const appPageExecutionPath = fileURLToPath(new URL("../server/app-page-execution.js", import.meta.url)).replace(/\\/g, "/");
+const appPageBoundaryRenderPath = fileURLToPath(new URL("../server/app-page-boundary-render.js", import.meta.url)).replace(/\\/g, "/");
+const appPageRenderPath = fileURLToPath(new URL("../server/app-page-render.js", import.meta.url)).replace(/\\/g, "/");
+const appPageRequestPath = fileURLToPath(new URL("../server/app-page-request.js", import.meta.url)).replace(/\\/g, "/");
+const appRouteHandlerResponsePath = fileURLToPath(new URL("../server/app-route-handler-response.js", import.meta.url)).replace(/\\/g, "/");
 const routeTriePath = fileURLToPath(new URL("../routing/route-trie.js", import.meta.url)).replace(/\\/g, "/");
-const routeHandlerHelperCode = String.raw`
-// Duplicated from the build-time constant above via JSON.stringify.
-const ROUTE_HANDLER_HTTP_METHODS = ${JSON.stringify([
-	"GET",
-	"HEAD",
-	"POST",
-	"PUT",
-	"DELETE",
-	"PATCH",
-	"OPTIONS"
-])};
-
-function collectRouteHandlerMethods(handler) {
-  const methods = ROUTE_HANDLER_HTTP_METHODS.filter((method) => typeof handler[method] === "function");
-  if (methods.includes("GET") && !methods.includes("HEAD")) {
-    methods.push("HEAD");
-  }
-  return methods;
-}
-
-function buildRouteHandlerAllowHeader(exportedMethods) {
-  const allow = new Set(exportedMethods);
-  allow.add("OPTIONS");
-  return Array.from(allow).sort().join(", ");
-}
-`;
 /**
 * Generate the virtual RSC entry module.
 *
@@ -198,7 +182,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 // 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 _hlFixRe = /(\\d*:HL\\[.*?),"stylesheet"(\\]|,)/g;
   const stream = _renderToReadableStream(model, options);
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
@@ -232,6 +216,42 @@ ${instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(inst
 ${effectiveMetaRoutes.length > 0 ? `import { sitemapToXml, robotsToText, manifestToJson } from ${JSON.stringify(fileURLToPath(new URL("../server/metadata-routes.js", import.meta.url)).replace(/\\/g, "/"))};` : ""}
 import { requestContextFromRequest, normalizeHost, matchRedirect, matchRewrite, matchHeaders, isExternalUrl, proxyExternalRequest, sanitizeDestination } from ${JSON.stringify(configMatchersPath)};
 import { validateCsrfOrigin, 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)};
+import { readAppRouteHandlerCacheResponse as __readAppRouteHandlerCacheResponse } from ${JSON.stringify(appRouteHandlerCachePath)};
+import { readAppPageCacheResponse as __readAppPageCacheResponse } from ${JSON.stringify(appPageCachePath)};
+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)};
+import {
+  renderAppPageLifecycle as __renderAppPageLifecycle,
+} from ${JSON.stringify(appPageRenderPath)};
+import {
+  buildAppPageElement as __buildAppPageElement,
+  resolveAppPageIntercept as __resolveAppPageIntercept,
+  validateAppPageDynamicParams as __validateAppPageDynamicParams,
+} 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 } from "vinext/fetch-cache";
@@ -245,7 +265,6 @@ import { getSSRFontStyles as _getSSRFontStylesLocal, getSSRFontPreloads as _getS
 function _getSSRFontStyles() { return [..._getSSRFontStylesGoogle(), ..._getSSRFontStylesLocal()]; }
 function _getSSRFontPreloads() { return [..._getSSRFontPreloadsGoogle(), ..._getSSRFontPreloadsLocal()]; }
 ${hasPagesDir ? `// Note: pageRoutes loaded lazily via SSR env in /__vinext/prerender/pages-static-paths handler` : ""}
-${routeHandlerHelperCode}
 
 // ALS used to suppress the expected "Invalid hook call" dev warning when
 // layout/page components are probed outside React's render cycle. Patching
@@ -438,15 +457,8 @@ function __errorDigest(str) {
 // unchanged since their digests are used for client-side routing.
 function __sanitizeErrorForClient(error) {
   // Navigation errors must pass through with their digest intact
-  if (error && typeof error === "object" && "digest" in error) {
-    const digest = String(error.digest);
-    if (
-      digest.startsWith("NEXT_REDIRECT;") ||
-      digest === "NEXT_NOT_FOUND" ||
-      digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;")
-    ) {
-      return error;
-    }
+  if (__resolveAppPageSpecialError(error)) {
+    return error;
   }
   // In development, pass through the original error for debugging
   if (process.env.NODE_ENV !== "production") {
@@ -604,139 +616,37 @@ const rootLayouts = [${rootLayoutVars.join(", ")}];
  * @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) {
-  // Determine which boundary component to use based on status code
-  let BoundaryComponent = opts?.boundaryComponent ?? null;
-  if (!BoundaryComponent) {
-    let boundaryModule;
-    if (statusCode === 403) {
-      boundaryModule = route?.forbidden ?? rootForbiddenModule;
-    } else if (statusCode === 401) {
-      boundaryModule = route?.unauthorized ?? rootUnauthorizedModule;
-    } else {
-      boundaryModule = route?.notFound ?? rootNotFoundModule;
-    }
-    BoundaryComponent = boundaryModule?.default ?? null;
-  }
-  const layouts = opts?.layouts ?? route?.layouts ?? rootLayouts;
-  if (!BoundaryComponent) return null;
-
-  // Resolve metadata and viewport from parent layouts so that not-found/error
-  // pages inherit title, description, OG tags etc. — matching Next.js behavior.
-  // Build the serial parent chain for layout metadata (same as buildPageElement).
-  const _filteredLayouts = layouts.filter(Boolean);
-  const _fallbackParams = opts?.matchedParams ?? route?.params ?? {};
-  const _layoutMetaPromises = [];
-  let _accumulatedMeta = Promise.resolve({});
-  for (let _i = 0; _i < _filteredLayouts.length; _i++) {
-    const _parentForLayout = _accumulatedMeta;
-    const _metaP = resolveModuleMetadata(_filteredLayouts[_i], _fallbackParams, undefined, _parentForLayout)
-      .catch((err) => { console.error("[vinext] Layout generateMetadata() failed:", err); return null; });
-    _layoutMetaPromises.push(_metaP);
-    _accumulatedMeta = _metaP.then(async (_r) =>
-      _r ? mergeMetadata([await _parentForLayout, _r]) : await _parentForLayout
-    );
-  }
-  const [_metaResults, _vpResults] = await Promise.all([
-    Promise.all(_layoutMetaPromises),
-    Promise.all(_filteredLayouts.map((mod) => resolveModuleViewport(mod, _fallbackParams).catch((err) => { console.error("[vinext] Layout generateViewport() failed:", err); return null; }))),
-  ]);
-  const metadataList = _metaResults.filter(Boolean);
-  const viewportList = _vpResults.filter(Boolean);
-  const resolvedMetadata = metadataList.length > 0 ? mergeMetadata(metadataList) : null;
-  const resolvedViewport = mergeViewport(viewportList);
-
-  // Build element: metadata head + noindex meta + boundary component wrapped in layouts
-  // Always include charset and default viewport for parity with Next.js.
-  const charsetMeta = createElement("meta", { charSet: "utf-8" });
-  const noindexMeta = createElement("meta", { name: "robots", content: "noindex" });
-  const headElements = [charsetMeta, noindexMeta];
-  if (resolvedMetadata) headElements.push(createElement(MetadataHead, { metadata: resolvedMetadata }));
-  headElements.push(createElement(ViewportHead, { viewport: resolvedViewport }));
-  let element = createElement(Fragment, null, ...headElements, createElement(BoundaryComponent));
-  if (isRscRequest) {
-    // For RSC requests (client-side navigation), wrap the element with the same
-    // component wrappers that buildPageElement() uses. Without these wrappers,
-    // React's reconciliation would see a mismatched tree structure between the
-    // old fiber tree (ErrorBoundary > LayoutSegmentProvider > html > body > NotFoundBoundary > ...)
-    // and the new tree (html > body > ...), causing it to destroy and recreate
-    // the entire DOM tree, resulting in a blank white page.
-    //
-    // We wrap each layout with LayoutSegmentProvider and add GlobalErrorBoundary
-    // to match the wrapping order in buildPageElement(), ensuring smooth
-    // client-side tree reconciliation.
-    const _treePositions = route?.layoutTreePositions;
-    const _routeSegs = route?.routeSegments || [];
-    const _fallbackParams = opts?.matchedParams ?? route?.params ?? {};
-    const _asyncFallbackParams = makeThenableParams(_fallbackParams);
-    for (let i = layouts.length - 1; i >= 0; i--) {
-      const LayoutComponent = layouts[i]?.default;
-      if (LayoutComponent) {
-        element = createElement(LayoutComponent, { children: element, params: _asyncFallbackParams });
-        const _tp = _treePositions ? _treePositions[i] : 0;
-        const _cs = __resolveChildSegments(_routeSegs, _tp, _fallbackParams);
-        element = createElement(LayoutSegmentProvider, { childSegments: _cs }, element);
-      }
-    }
-    ${globalErrorVar ? `
-    const _GlobalErrorComponent = ${globalErrorVar}.default;
-    if (_GlobalErrorComponent) {
-      element = createElement(ErrorBoundary, {
-        fallback: _GlobalErrorComponent,
-        children: element,
-      });
-    }
-    ` : ""}
-    const _pathname = new URL(request.url).pathname;
-    const onRenderError = createRscOnErrorHandler(
-      request,
-      _pathname,
-      route?.pattern ?? _pathname,
-    );
-    const rscStream = renderToReadableStream(element, { onError: onRenderError });
-    // Do NOT clear context here — the RSC stream is consumed lazily by the client.
-    // Clearing context now would cause async server components (e.g. NextIntlClientProviderServer)
-    // that run during stream consumption to see null headers/navigation context and throw,
-    // resulting in missing provider context on the client (e.g. next-intl useTranslations fails
-    // with "context from NextIntlClientProvider was not found").
-    // Context is cleared naturally when the ALS scope from runWithRequestContext unwinds.
-    return new Response(rscStream, {
-      status: statusCode,
-      headers: { "Content-Type": "text/x-component; charset=utf-8", "Vary": "RSC, Accept" },
-    });
-  }
-  // For HTML (full page load) responses, wrap with layouts only (no client-side
-  // wrappers needed since SSR generates the complete HTML document).
-  const _fallbackParamsHtml = opts?.matchedParams ?? route?.params ?? {};
-  const _asyncFallbackParamsHtml = makeThenableParams(_fallbackParamsHtml);
-  for (let i = layouts.length - 1; i >= 0; i--) {
-    const LayoutComponent = layouts[i]?.default;
-    if (LayoutComponent) {
-      element = createElement(LayoutComponent, { children: element, params: _asyncFallbackParamsHtml });
-    }
-  }
-  const _pathname = new URL(request.url).pathname;
-  const onRenderError = createRscOnErrorHandler(
-    request,
-    _pathname,
-    route?.pattern ?? _pathname,
-  );
-  const rscStream = renderToReadableStream(element, { onError: onRenderError });
-  // Collect font data from RSC environment
-  const fontData = {
-    links: _getSSRFontLinks(),
-    styles: _getSSRFontStyles(),
-    preloads: _getSSRFontPreloads(),
-  };
-  const ssrEntry = await import.meta.viteRsc.loadModule("ssr", "index");
-  const htmlStream = await ssrEntry.handleSsr(rscStream, _getNavigationContext(), fontData);
-  setHeadersContext(null);
-  setNavigationContext(null);
-  const _respHeaders = { "Content-Type": "text/html; charset=utf-8", "Vary": "RSC, Accept" };
-  const _linkParts = (fontData.preloads || []).map(function(p) { return "<" + p.href + ">; rel=preload; as=font; type=" + p.type + "; crossorigin"; });
-  if (_linkParts.length > 0) _respHeaders["Link"] = _linkParts.join(", ");
-  return new Response(htmlStream, {
-    status: statusCode,
-    headers: _respHeaders,
+  return __renderAppPageHttpAccessFallback({
+    boundaryComponent: opts?.boundaryComponent ?? null,
+    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 ?? {},
+    requestUrl: request.url,
+    resolveChildSegments: __resolveChildSegments,
+    rootForbiddenModule: rootForbiddenModule,
+    rootLayouts: rootLayouts,
+    rootNotFoundModule: rootNotFoundModule,
+    rootUnauthorizedModule: rootUnauthorizedModule,
+    route,
+    renderToReadableStream,
+    statusCode,
   });
 }
 
@@ -753,122 +663,33 @@ async function renderNotFoundPage(route, isRscRequest, request, matchedParams) {
  * by the boundary). This matches that behavior intentionally.
  */
 async function renderErrorBoundaryPage(route, error, isRscRequest, request, matchedParams) {
-  // Resolve the error boundary component: leaf error.tsx first, then walk per-layout
-  // errors from innermost to outermost (matching ancestor inheritance), then global-error.tsx.
-  let ErrorComponent = route?.error?.default ?? null;
-  let _isGlobalError = false;
-  if (!ErrorComponent && route?.errors) {
-    for (let i = route.errors.length - 1; i >= 0; i--) {
-      if (route.errors[i]?.default) {
-        ErrorComponent = route.errors[i].default;
-        break;
-      }
-    }
-  }
-  ${globalErrorVar ? `
-  if (!ErrorComponent) {
-    ErrorComponent = ${globalErrorVar}?.default ?? null;
-    _isGlobalError = !!ErrorComponent;
-  }
-  ` : ""}
-  if (!ErrorComponent) return null;
-
-  const rawError = error instanceof Error ? error : new Error(String(error));
-  // Sanitize the error in production to avoid leaking internal details
-  // (database errors, file paths, stack traces) through error.tsx to the client.
-  // In development, pass the original error for debugging.
-  const errorObj = __sanitizeErrorForClient(rawError);
-  // Only pass error — reset is a client-side concern (re-renders the segment) and
-  // can't be serialized through RSC. The error.tsx component will receive reset=undefined
-  // during SSR, which is fine — onClick={undefined} is harmless, and the real reset
-  // function is only meaningful after hydration.
-  let element = createElement(ErrorComponent, {
-    error: errorObj,
-  });
-
-  // global-error.tsx provides its own <html> and <body> (it replaces the root
-  // layout). Skip layout wrapping when rendering it to avoid double <html> tags.
-  if (!_isGlobalError) {
-    const layouts = route?.layouts ?? rootLayouts;
-    if (isRscRequest) {
-      // For RSC requests (client-side navigation), wrap with the same component
-      // wrappers that buildPageElement() uses (LayoutSegmentProvider, GlobalErrorBoundary).
-      // This ensures React can reconcile the tree without destroying the DOM.
-      // Same rationale as renderHTTPAccessFallbackPage — see comment there.
-      const _errTreePositions = route?.layoutTreePositions;
-      const _errRouteSegs = route?.routeSegments || [];
-      const _errParams = matchedParams ?? route?.params ?? {};
-      const _asyncErrParams = makeThenableParams(_errParams);
-      for (let i = layouts.length - 1; i >= 0; i--) {
-        const LayoutComponent = layouts[i]?.default;
-        if (LayoutComponent) {
-          element = createElement(LayoutComponent, { children: element, params: _asyncErrParams });
-          const _etp = _errTreePositions ? _errTreePositions[i] : 0;
-          const _ecs = __resolveChildSegments(_errRouteSegs, _etp, _errParams);
-          element = createElement(LayoutSegmentProvider, { childSegments: _ecs }, element);
-        }
-      }
-      ${globalErrorVar ? `
-      const _ErrGlobalComponent = ${globalErrorVar}.default;
-      if (_ErrGlobalComponent) {
-        element = createElement(ErrorBoundary, {
-          fallback: _ErrGlobalComponent,
-          children: element,
-        });
-      }
-      ` : ""}
-    } else {
-      // For HTML (full page load) responses, wrap with layouts only.
-      const _errParamsHtml = matchedParams ?? route?.params ?? {};
-      const _asyncErrParamsHtml = makeThenableParams(_errParamsHtml);
-      for (let i = layouts.length - 1; i >= 0; i--) {
-        const LayoutComponent = layouts[i]?.default;
-        if (LayoutComponent) {
-          element = createElement(LayoutComponent, { children: element, params: _asyncErrParamsHtml });
-        }
-      }
-    }
-  }
-
-  const _pathname = new URL(request.url).pathname;
-  const onRenderError = createRscOnErrorHandler(
-    request,
-    _pathname,
-    route?.pattern ?? _pathname,
-  );
-
-  if (isRscRequest) {
-    const rscStream = renderToReadableStream(element, { onError: onRenderError });
-    // Do NOT clear context here — the RSC stream is consumed lazily by the client.
-    // Clearing context now would cause async server components (e.g. NextIntlClientProviderServer)
-    // that run during stream consumption to see null headers/navigation context and throw,
-    // resulting in missing provider context on the client (e.g. next-intl useTranslations fails
-    // with "context from NextIntlClientProvider was not found").
-    // Context is cleared naturally when the ALS scope from runWithRequestContext unwinds.
-    return new Response(rscStream, {
-      status: 200,
-      headers: { "Content-Type": "text/x-component; charset=utf-8", "Vary": "RSC, Accept" },
-    });
-  }
-
-  // HTML (full page load) response — render through RSC → SSR pipeline
-  const rscStream = renderToReadableStream(element, { onError: onRenderError });
-  // Collect font data from RSC environment so error pages include font styles
-  const fontData = {
-    links: _getSSRFontLinks(),
-    styles: _getSSRFontStyles(),
-    preloads: _getSSRFontPreloads(),
-  };
-  const ssrEntry = await import.meta.viteRsc.loadModule("ssr", "index");
-  const htmlStream = await ssrEntry.handleSsr(rscStream, _getNavigationContext(), fontData);
-  setHeadersContext(null);
-  setNavigationContext(null);
-  const _errHeaders = { "Content-Type": "text/html; charset=utf-8", "Vary": "RSC, Accept" };
-  const _errLinkParts = (fontData.preloads || []).map(function(p) { return "<" + p.href + ">; rel=preload; as=font; type=" + p.type + "; crossorigin"; });
-  if (_errLinkParts.length > 0) _errHeaders["Link"] = _errLinkParts.join(", ");
-  return new Response(htmlStream, {
-    status: 200,
-    headers: _errHeaders,
+  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 ?? {},
+    requestUrl: request.url,
+    resolveChildSegments: __resolveChildSegments,
+    rootLayouts: rootLayouts,
+    route,
+    renderToReadableStream,
+    sanitizeErrorForClient: __sanitizeErrorForClient,
   });
 }
 
@@ -1418,8 +1239,6 @@ export default async function handler(request, ctx) {
 
 async function _handleRequest(request, __reqCtx, _mwCtx) {
   const __reqStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
-  let __compileEnd;
-  let __renderEnd;
   // __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.
@@ -2037,266 +1856,132 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
   if (route.routeHandler) {
     const handler = route.routeHandler;
     const method = request.method.toUpperCase();
-    const revalidateSeconds = typeof handler.revalidate === "number" && handler.revalidate > 0 && handler.revalidate !== Infinity ? handler.revalidate : null;
-    if (typeof handler["default"] === "function" && process.env.NODE_ENV === "development") {
+    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.",
       );
     }
 
-    // Collect exported HTTP methods for OPTIONS auto-response and Allow header
-    const exportedMethods = collectRouteHandlerMethods(handler);
-    const allowHeaderForOptions = buildRouteHandlerAllowHeader(exportedMethods);
-
-    // Route handlers need the same middleware header/status merge behavior as
-    // page responses. This keeps middleware response headers visible on API
-    // routes in Workers/dev, and preserves custom rewrite status overrides.
-    function attachRouteHandlerMiddlewareContext(response) {
-      // _mwCtx.headers is only set (non-null) when middleware actually ran and
-      // produced a continue/rewrite response. An empty Headers object (middleware
-      // ran but produced no response headers) is a harmless edge case: the early
-      // return is skipped, but the copy loop below is a no-op, so no incorrect
-      // headers are added. The allocation cost in that case is acceptable.
-      if (!_mwCtx.headers && _mwCtx.status == null) return response;
-      const responseHeaders = new Headers(response.headers);
-      if (_mwCtx.headers) {
-        for (const [key, value] of _mwCtx.headers) {
-          responseHeaders.append(key, value);
-        }
-      }
-      return new Response(response.body, {
-        status: _mwCtx.status ?? response.status,
-        statusText: response.statusText,
-        headers: responseHeaders,
-      });
-    }
+    const {
+      allowHeaderForOptions,
+      handlerFn,
+      isAutoHead,
+      shouldAutoRespondToOptions,
+    } = __resolveAppRouteHandlerMethod(handler, method);
 
-    // OPTIONS auto-implementation: respond with Allow header and 204
-    if (method === "OPTIONS" && typeof handler["OPTIONS"] !== "function") {
+    if (shouldAutoRespondToOptions) {
       setHeadersContext(null);
       setNavigationContext(null);
-      return attachRouteHandlerMiddlewareContext(new Response(null, {
-        status: 204,
-        headers: { "Allow": allowHeaderForOptions },
-      }));
-    }
-
-    // HEAD auto-implementation: run GET handler and strip body
-    let handlerFn = handler[method];
-    let isAutoHead = false;
-    if (method === "HEAD" && typeof handler["HEAD"] !== "function" && typeof handler["GET"] === "function") {
-      handlerFn = handler["GET"];
-      isAutoHead = true;
+      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.
-    // This runs before handler execution so a cache HIT skips the handler entirely.
+    // 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 (
-      process.env.NODE_ENV === "production" &&
-      revalidateSeconds !== null &&
-      handler.dynamic !== "force-dynamic" &&
-      (method === "GET" || isAutoHead) &&
-      typeof handlerFn === "function"
+      __shouldReadAppRouteHandlerCache({
+        dynamicConfig: handler.dynamic,
+        handlerFn,
+        isAutoHead,
+        isKnownDynamic: __isKnownDynamicAppRoute(route.pattern),
+        isProduction: process.env.NODE_ENV === "production",
+        method,
+        revalidateSeconds,
+      })
     ) {
-      const __routeKey = __isrRouteKey(cleanPathname);
-      try {
-        const __cached = await __isrGet(__routeKey);
-        if (__cached && !__cached.isStale && __cached.value.value && __cached.value.value.kind === "APP_ROUTE") {
-          // HIT — return cached response immediately
-          const __cv = __cached.value.value;
-          __isrDebug?.("HIT (route)", cleanPathname);
+      const __cachedRouteResponse = await __readAppRouteHandlerCacheResponse({
+        basePath: __basePath,
+        buildPageCacheTags: __pageCacheTags,
+        cleanPathname,
+        clearRequestContext: function() {
           setHeadersContext(null);
           setNavigationContext(null);
-          const __hitHeaders = Object.assign({}, __cv.headers || {});
-          __hitHeaders["X-Vinext-Cache"] = "HIT";
-          __hitHeaders["Cache-Control"] = "s-maxage=" + revalidateSeconds + ", stale-while-revalidate";
-          if (isAutoHead) {
-            return attachRouteHandlerMiddlewareContext(new Response(null, { status: __cv.status, headers: __hitHeaders }));
-          }
-          return attachRouteHandlerMiddlewareContext(new Response(__cv.body, { status: __cv.status, headers: __hitHeaders }));
-        }
-        if (__cached && __cached.isStale && __cached.value.value && __cached.value.value.kind === "APP_ROUTE") {
-          // STALE — serve stale response, trigger background regeneration
-          const __sv = __cached.value.value;
-          const __revalSecs = revalidateSeconds;
-          const __revalHandlerFn = handlerFn;
-          const __revalParams = params;
-          const __revalUrl = request.url;
-          const __revalSearchParams = new URLSearchParams(url.searchParams);
-          __triggerBackgroundRegeneration(__routeKey, async function() {
-            const __revalHeadCtx = { headers: new Headers(), cookies: new Map() };
-            const __revalUCtx = _createUnifiedCtx({
-              headersContext: __revalHeadCtx,
-              executionContext: _getRequestExecutionContext(),
-            });
-            await _runWithUnifiedCtx(__revalUCtx, async () => {
-              _ensureFetchPatch();
-              setNavigationContext({ pathname: cleanPathname, searchParams: __revalSearchParams, params: __revalParams });
-              const __syntheticReq = new Request(__revalUrl, { method: "GET" });
-              const __revalResponse = await __revalHandlerFn(__syntheticReq, { params: __revalParams });
-              const __regenDynamic = consumeDynamicUsage();
-              setNavigationContext(null);
-              if (__regenDynamic) {
-                __isrDebug?.("route regen skipped (dynamic usage)", cleanPathname);
-                return;
-              }
-              const __freshBody = await __revalResponse.arrayBuffer();
-              const __freshHeaders = {};
-              __revalResponse.headers.forEach(function(v, k) {
-                if (k !== "x-vinext-cache" && k !== "cache-control") __freshHeaders[k] = v;
-              });
-              const __routeTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
-              await __isrSet(__routeKey, { kind: "APP_ROUTE", body: __freshBody, status: __revalResponse.status, headers: __freshHeaders }, __revalSecs, __routeTags);
-              __isrDebug?.("route regen complete", __routeKey);
-            });
+        },
+        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(),
           });
-          __isrDebug?.("STALE (route)", cleanPathname);
-          setHeadersContext(null);
-          setNavigationContext(null);
-          const __staleHeaders = Object.assign({}, __sv.headers || {});
-          __staleHeaders["X-Vinext-Cache"] = "STALE";
-          __staleHeaders["Cache-Control"] = "s-maxage=0, stale-while-revalidate";
-          if (isAutoHead) {
-            return attachRouteHandlerMiddlewareContext(new Response(null, { status: __sv.status, headers: __staleHeaders }));
-          }
-          return attachRouteHandlerMiddlewareContext(new Response(__sv.body, { status: __sv.status, headers: __staleHeaders }));
-        }
-      } catch (__routeCacheErr) {
-        // Cache read failure — fall through to normal handler execution
-        console.error("[vinext] ISR route cache read error:", __routeCacheErr);
+          await _runWithUnifiedCtx(__revalUCtx, async () => {
+            _ensureFetchPatch();
+            await renderFn();
+          });
+        },
+        scheduleBackgroundRegeneration: __triggerBackgroundRegeneration,
+        setNavigationContext,
+      });
+      if (__cachedRouteResponse) {
+        return __cachedRouteResponse;
       }
     }
 
     if (typeof handlerFn === "function") {
-      const previousHeadersPhase = setHeadersAccessPhase("route-handler");
-      try {
-        const response = await handlerFn(request, { params });
-        const dynamicUsedInHandler = consumeDynamicUsage();
-        const handlerSetCacheControl = response.headers.has("cache-control");
-
-        // Apply Cache-Control from route segment config (export const revalidate = N).
-        // Runtime request APIs like headers() / cookies() make GET handlers dynamic,
-        // so only attach ISR headers when the handler stayed static.
-        if (
-          revalidateSeconds !== null &&
-          !dynamicUsedInHandler &&
-          (method === "GET" || isAutoHead) &&
-          !handlerSetCacheControl
-        ) {
-          response.headers.set("cache-control", "s-maxage=" + revalidateSeconds + ", stale-while-revalidate");
-        }
-
-        // ISR cache write for route handlers (production, MISS).
-        // Store the raw handler response before cookie/middleware transforms
-        // (those are request-specific and shouldn't be cached).
-        if (
-          process.env.NODE_ENV === "production" &&
-          revalidateSeconds !== null &&
-          handler.dynamic !== "force-dynamic" &&
-          !dynamicUsedInHandler &&
-          (method === "GET" || isAutoHead) &&
-          !handlerSetCacheControl
-        ) {
-          response.headers.set("X-Vinext-Cache", "MISS");
-          const __routeClone = response.clone();
-          const __routeKey = __isrRouteKey(cleanPathname);
-          const __revalSecs = revalidateSeconds;
-          const __routeTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
-          const __routeWritePromise = (async () => {
-            try {
-              const __buf = await __routeClone.arrayBuffer();
-              const __hdrs = {};
-              __routeClone.headers.forEach(function(v, k) {
-                if (k !== "x-vinext-cache" && k !== "cache-control") __hdrs[k] = v;
-              });
-              await __isrSet(__routeKey, { kind: "APP_ROUTE", body: __buf, status: __routeClone.status, headers: __hdrs }, __revalSecs, __routeTags);
-              __isrDebug?.("route cache written", __routeKey);
-            } catch (__cacheErr) {
-              console.error("[vinext] ISR route cache write error:", __cacheErr);
-            }
-          })();
-          _getRequestExecutionContext()?.waitUntil(__routeWritePromise);
-        }
-
-        // Collect any Set-Cookie headers from cookies().set()/delete() calls
-        const pendingCookies = getAndClearPendingCookies();
-        const draftCookie = getDraftModeCookieHeader();
-        setHeadersContext(null);
-        setNavigationContext(null);
-
-        // If we have pending cookies, create a new response with them attached
-        if (pendingCookies.length > 0 || draftCookie) {
-          const newHeaders = new Headers(response.headers);
-          for (const cookie of pendingCookies) {
-            newHeaders.append("Set-Cookie", cookie);
-          }
-          if (draftCookie) newHeaders.append("Set-Cookie", draftCookie);
-
-          if (isAutoHead) {
-            return attachRouteHandlerMiddlewareContext(new Response(null, {
-              status: response.status,
-              statusText: response.statusText,
-              headers: newHeaders,
-            }));
-          }
-          return attachRouteHandlerMiddlewareContext(new Response(response.body, {
-            status: response.status,
-            statusText: response.statusText,
-            headers: newHeaders,
-          }));
-        }
-
-        if (isAutoHead) {
-          // Strip body for auto-HEAD, preserve headers and status
-          return attachRouteHandlerMiddlewareContext(new Response(null, {
-            status: response.status,
-            statusText: response.statusText,
-            headers: response.headers,
-          }));
-        }
-        return attachRouteHandlerMiddlewareContext(response);
-      } catch (err) {
-        getAndClearPendingCookies(); // Clear any pending cookies on error
-        // Catch redirect() / notFound() thrown from route handlers
-        if (err && typeof err === "object" && "digest" in err) {
-          const digest = String(err.digest);
-          if (digest.startsWith("NEXT_REDIRECT;")) {
-            const parts = digest.split(";");
-            const redirectUrl = decodeURIComponent(parts[2]);
-            const statusCode = parts[3] ? parseInt(parts[3], 10) : 307;
-            setHeadersContext(null);
-            setNavigationContext(null);
-            return attachRouteHandlerMiddlewareContext(new Response(null, {
-              status: statusCode,
-              headers: { Location: new URL(redirectUrl, request.url).toString() },
-            }));
-          }
-          if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;")) {
-            const statusCode = digest === "NEXT_NOT_FOUND" ? 404 : parseInt(digest.split(";")[1], 10);
-            setHeadersContext(null);
-            setNavigationContext(null);
-            return attachRouteHandlerMiddlewareContext(new Response(null, { status: statusCode }));
-          }
-        }
-        setHeadersContext(null);
-        setNavigationContext(null);
-        console.error("[vinext] Route handler 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: route.pattern, routeType: "route" },
-        );
-        return attachRouteHandlerMiddlewareContext(new Response(null, { status: 500 }));
-      } finally {
-        setHeadersAccessPhase(previousHeadersPhase);
-      }
+      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,
+        params,
+        reportRequestError: _reportRequestError,
+        request,
+        revalidateSeconds,
+        routePattern: route.pattern,
+        setHeadersAccessPhase,
+      });
     }
     setHeadersContext(null);
     setNavigationContext(null);
-    return attachRouteHandlerMiddlewareContext(new Response(null, {
-      status: 405,
-    }));
+    return __applyRouteHandlerMiddlewareContext(
+      new Response(null, {
+        status: 405,
+      }),
+      _mwCtx,
+    );
   }
 
   // Build the component tree: layouts wrapping the page
@@ -2366,776 +2051,270 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
     !isForceDynamic &&
     revalidateSeconds !== null && revalidateSeconds > 0 && revalidateSeconds !== Infinity
   ) {
-    const __isrKey = isRscRequest ? __isrRscKey(cleanPathname) : __isrHtmlKey(cleanPathname);
-    try {
-      const __cached = await __isrGet(__isrKey);
-      if (__cached && !__cached.isStale && __cached.value.value && __cached.value.value.kind === "APP_PAGE") {
-        const __cachedValue = __cached.value.value;
-        const __hasRsc = !!__cachedValue.rscData;
-        const __hasHtml = typeof __cachedValue.html === "string" && __cachedValue.html.length > 0;
-        if (isRscRequest && __hasRsc) {
-          __isrDebug?.("HIT (RSC)", cleanPathname);
-          setHeadersContext(null);
-          setNavigationContext(null);
-          return new Response(__cachedValue.rscData, {
-            status: __cachedValue.status || 200,
-            headers: {
-              "Content-Type": "text/x-component; charset=utf-8",
-              "Cache-Control": "s-maxage=" + revalidateSeconds + ", stale-while-revalidate",
-              "Vary": "RSC, Accept",
-              "X-Vinext-Cache": "HIT",
-            },
-          });
-        }
-        if (!isRscRequest && __hasHtml) {
-          __isrDebug?.("HIT (HTML)", cleanPathname);
-          setHeadersContext(null);
-          setNavigationContext(null);
-          return new Response(__cachedValue.html, {
-            status: __cachedValue.status || 200,
-            headers: {
-              "Content-Type": "text/html; charset=utf-8",
-              "Cache-Control": "s-maxage=" + revalidateSeconds + ", stale-while-revalidate",
-              "Vary": "RSC, Accept",
-              "X-Vinext-Cache": "HIT",
-            },
-          });
-        }
-        __isrDebug?.("MISS (empty cached entry)", cleanPathname);
-      }
-      if (__cached && __cached.isStale && __cached.value.value && __cached.value.value.kind === "APP_PAGE") {
-        // Stale cache hit — serve stale immediately, trigger background regeneration.
-        // Regen writes both keys independently so neither path blocks on the other.
-        const __staleValue = __cached.value.value;
-        const __staleStatus = __staleValue.status || 200;
-        const __revalSecs = revalidateSeconds;
-        __triggerBackgroundRegeneration(cleanPathname, 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(),
-          });
-          const __revalResult = await _runWithUnifiedCtx(__revalUCtx, async () => {
-            _ensureFetchPatch();
-            setNavigationContext({ pathname: cleanPathname, searchParams: new URLSearchParams(), params });
-            const __revalElement = await buildPageElement(route, params, undefined, new URLSearchParams());
-            const __revalOnError = createRscOnErrorHandler(request, cleanPathname, route.pattern);
-            const __revalRscStream = renderToReadableStream(__revalElement, { onError: __revalOnError });
-            // Tee RSC stream: one for SSR, one to capture rscData
-            const [__revalRscForSsr, __revalRscForCapture] = __revalRscStream.tee();
-            // Capture rscData bytes in parallel with SSR
-            const __rscDataPromise = (async () => {
-              const __rscReader = __revalRscForCapture.getReader();
-              const __rscChunks = [];
-              let __rscTotal = 0;
-              for (;;) {
-                const { done, value } = await __rscReader.read();
-                if (done) break;
-                __rscChunks.push(value);
-                __rscTotal += value.byteLength;
-              }
-              const __rscBuf = new Uint8Array(__rscTotal);
-              let __rscOff = 0;
-              for (const c of __rscChunks) { __rscBuf.set(c, __rscOff); __rscOff += c.byteLength; }
-              return __rscBuf.buffer;
-            })();
-            const __revalFontData = { links: _getSSRFontLinks(), styles: _getSSRFontStyles(), preloads: _getSSRFontPreloads() };
-            const __revalSsrEntry = await import.meta.viteRsc.loadModule("ssr", "index");
-            const __revalHtmlStream = await __revalSsrEntry.handleSsr(__revalRscForSsr, _getNavigationContext(), __revalFontData);
-            setHeadersContext(null);
-            setNavigationContext(null);
-            // Collect the full HTML string from the stream
-            const __revalReader = __revalHtmlStream.getReader();
-            const __revalDecoder = new TextDecoder();
-            const __revalChunks = [];
-            for (;;) {
-              const { done, value } = await __revalReader.read();
-              if (done) break;
-              __revalChunks.push(__revalDecoder.decode(value, { stream: true }));
-            }
-            __revalChunks.push(__revalDecoder.decode());
-            const __freshHtml = __revalChunks.join("");
-            const __freshRscData = await __rscDataPromise;
-            const __pageTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
-            return { html: __freshHtml, rscData: __freshRscData, tags: __pageTags };
-          });
-          // Write HTML and RSC to their own keys independently — no races
-          await Promise.all([
-            __isrSet(__isrHtmlKey(cleanPathname), { kind: "APP_PAGE", html: __revalResult.html, rscData: undefined, headers: undefined, postponed: undefined, status: 200 }, __revalSecs, __revalResult.tags),
-            __isrSet(__isrRscKey(cleanPathname), { kind: "APP_PAGE", html: "", rscData: __revalResult.rscData, headers: undefined, postponed: undefined, status: 200 }, __revalSecs, __revalResult.tags),
-          ]);
-          __isrDebug?.("regen complete", cleanPathname);
+    const __cachedPageResponse = await __readAppPageCacheResponse({
+      cleanPathname,
+      clearRequestContext: function() {
+        setHeadersContext(null);
+        setNavigationContext(null);
+      },
+      isRscRequest,
+      isrDebug: __isrDebug,
+      isrGet: __isrGet,
+      isrHtmlKey: __isrHtmlKey,
+      isrRscKey: __isrRscKey,
+      isrSet: __isrSet,
+      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(),
         });
-        if (isRscRequest && __staleValue.rscData) {
-          __isrDebug?.("STALE (RSC)", cleanPathname);
+        return _runWithUnifiedCtx(__revalUCtx, async () => {
+          _ensureFetchPatch();
+          setNavigationContext({ pathname: cleanPathname, searchParams: new URLSearchParams(), params });
+          const __revalElement = await buildPageElement(route, params, undefined, new URLSearchParams());
+          const __revalOnError = createRscOnErrorHandler(request, cleanPathname, route.pattern);
+          const __revalRscStream = renderToReadableStream(__revalElement, { onError: __revalOnError });
+          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);
-          return new Response(__staleValue.rscData, {
-            status: __staleStatus,
-            headers: {
-              "Content-Type": "text/x-component; charset=utf-8",
-              "Cache-Control": "s-maxage=0, stale-while-revalidate",
-              "Vary": "RSC, Accept",
-              "X-Vinext-Cache": "STALE",
-            },
-          });
-        }
-        if (!isRscRequest && typeof __staleValue.html === "string" && __staleValue.html.length > 0) {
-          __isrDebug?.("STALE (HTML)", cleanPathname);
-          setHeadersContext(null);
-          setNavigationContext(null);
-          return new Response(__staleValue.html, {
-            status: __staleStatus,
-            headers: {
-              "Content-Type": "text/html; charset=utf-8",
-              "Cache-Control": "s-maxage=0, stale-while-revalidate",
-              "Vary": "RSC, Accept",
-              "X-Vinext-Cache": "STALE",
-            },
-          });
-        }
-        // Stale entry exists but is empty for this request type — fall through to render
-        __isrDebug?.("STALE MISS (empty stale entry)", cleanPathname);
-      }
-      if (!__cached) {
-        __isrDebug?.("MISS (no cache entry)", cleanPathname);
-      }
-    } catch (__isrReadErr) {
-      // Cache read failure — fall through to normal rendering
-      console.error("[vinext] ISR cache read error:", __isrReadErr);
+          const __freshHtml = await __readAppPageTextStream(__revalHtmlStream);
+          const __freshRscData = await __revalRscCapture.capturedRscDataPromise;
+          const __pageTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
+          return { html: __freshHtml, rscData: __freshRscData, tags: __pageTags };
+        });
+      },
+      scheduleBackgroundRegeneration: __triggerBackgroundRegeneration,
+    });
+    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.
-  if (dynamicParamsConfig === false && route.isDynamic && typeof route.page?.generateStaticParams === "function") {
-    try {
-      // Pass parent params to generateStaticParams (Next.js top-down params passing).
-      // Parent params = all matched params that DON'T belong to the leaf page's own dynamic segments.
-      // We pass the full matched params; the function uses only what it needs.
-      const staticParams = await route.page.generateStaticParams({ params });
-      if (Array.isArray(staticParams)) {
-        const paramKeys = Object.keys(params);
-        const isAllowed = staticParams.some(sp =>
-          paramKeys.every(key => {
-            const val = params[key];
-            const staticVal = sp[key];
-            // Allow parent params to not be in the returned set (they're inherited)
-            if (staticVal === undefined) return true;
-            if (Array.isArray(val)) return JSON.stringify(val) === JSON.stringify(staticVal);
-            return String(val) === String(staticVal);
-          })
-        );
-        if (!isAllowed) {
-          setHeadersContext(null);
-          setNavigationContext(null);
-          return new Response("Not Found", { status: 404 });
-        }
-      }
-    } catch (err) {
+  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);
-    }
+    },
+    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.
-  let interceptOpts = undefined;
-  if (isRscRequest) {
-    const intercept = findIntercept(cleanPathname);
-    if (intercept) {
-      const sourceRoute = routes[intercept.sourceRouteIndex];
-      if (sourceRoute && sourceRoute !== route) {
-        // Render the source route (e.g. /feed) with the intercepting page in the slot
-        const sourceMatch = matchRoute(sourceRoute.pattern);
-        const sourceParams = sourceMatch ? sourceMatch.params : {};
-        setNavigationContext({
-          pathname: cleanPathname,
-          searchParams: url.searchParams,
-          params: intercept.matchedParams,
-        });
-        const interceptElement = await buildPageElement(sourceRoute, sourceParams, {
-          interceptSlot: intercept.slotName,
-          interceptPage: intercept.page,
-          interceptParams: intercept.matchedParams,
-        }, url.searchParams);
-        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.
-        return new Response(interceptStream, {
-          headers: { "Content-Type": "text/x-component; charset=utf-8", "Vary": "RSC, Accept" },
-        });
-      }
-      // If sourceRoute === route, apply intercept opts to the normal render
-      interceptOpts = {
+  const __interceptResult = await __resolveAppPageIntercept({
+    buildPageElement,
+    cleanPathname,
+    currentRoute: route,
+    findIntercept,
+    getRoutePattern(sourceRoute) {
+      return sourceRoute.pattern;
+    },
+    getSourceRoute(sourceRouteIndex) {
+      return routes[sourceRouteIndex];
+    },
+    isRscRequest,
+    matchSourceRouteParams(pattern) {
+      return matchRoute(pattern)?.params ?? {};
+    },
+    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.
+      return new Response(interceptStream, {
+        headers: { "Content-Type": "text/x-component; charset=utf-8", "Vary": "RSC, Accept" },
+      });
+    },
+    searchParams: url.searchParams,
+    setNavigationContext,
+    toInterceptOpts(intercept) {
+      return {
         interceptSlot: intercept.slotName,
         interceptPage: intercept.page,
         interceptParams: intercept.matchedParams,
       };
-    }
+    },
+  });
+  if (__interceptResult.response) {
+    return __interceptResult.response;
   }
+  const interceptOpts = __interceptResult.interceptOpts;
 
-  let element;
-  try {
-    element = await buildPageElement(route, params, interceptOpts, url.searchParams);
-  } catch (buildErr) {
-    // Check for redirect/notFound/forbidden/unauthorized thrown during metadata resolution or async components
-    if (buildErr && typeof buildErr === "object" && "digest" in buildErr) {
-      const digest = String(buildErr.digest);
-      if (digest.startsWith("NEXT_REDIRECT;")) {
-        const parts = digest.split(";");
-        const redirectUrl = decodeURIComponent(parts[2]);
-        const statusCode = parts[3] ? parseInt(parts[3], 10) : 307;
-        setHeadersContext(null);
-        setNavigationContext(null);
-        return Response.redirect(new URL(redirectUrl, request.url), statusCode);
-      }
-      if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;")) {
-        const statusCode = digest === "NEXT_NOT_FOUND" ? 404 : parseInt(digest.split(";")[1], 10);
-        const fallbackResp = await renderHTTPAccessFallbackPage(route, statusCode, isRscRequest, request, { matchedParams: params });
-        if (fallbackResp) return fallbackResp;
-        setHeadersContext(null);
-        setNavigationContext(null);
-        const statusText = statusCode === 403 ? "Forbidden" : statusCode === 401 ? "Unauthorized" : "Not Found";
-        return new Response(statusText, { status: statusCode });
-      }
-    }
-    // Non-special error (e.g. generateMetadata() threw) — render error.tsx if available
-    const errorBoundaryResp = await renderErrorBoundaryPage(route, buildErr, isRscRequest, request, params);
-    if (errorBoundaryResp) return errorBoundaryResp;
-    throw buildErr;
+  const __pageBuildResult = await __buildAppPageElement({
+    buildPageElement() {
+      return buildPageElement(route, params, interceptOpts, url.searchParams);
+    },
+    renderErrorBoundaryPage(buildErr) {
+      return renderErrorBoundaryPage(route, buildErr, isRscRequest, request, params);
+    },
+    renderSpecialError(__buildSpecialError) {
+      return __buildAppPageSpecialErrorResponse({
+        clearRequestContext() {
+          setHeadersContext(null);
+          setNavigationContext(null);
+        },
+        renderFallbackPage(statusCode) {
+          return renderHTTPAccessFallbackPage(route, statusCode, isRscRequest, request, {
+            matchedParams: params,
+          });
+        },
+        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.
-
-  // Helper: check if an error is a redirect/notFound/forbidden/unauthorized thrown by the navigation shim
-  async function handleRenderError(err) {
-    if (err && typeof err === "object" && "digest" in err) {
-      const digest = String(err.digest);
-      if (digest.startsWith("NEXT_REDIRECT;")) {
-        const parts = digest.split(";");
-        const redirectUrl = decodeURIComponent(parts[2]);
-        const statusCode = parts[3] ? parseInt(parts[3], 10) : 307;
-        setHeadersContext(null);
-        setNavigationContext(null);
-        return Response.redirect(new URL(redirectUrl, request.url), statusCode);
-      }
-      if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;")) {
-        const statusCode = digest === "NEXT_NOT_FOUND" ? 404 : parseInt(digest.split(";")[1], 10);
-        const fallbackResp = await renderHTTPAccessFallbackPage(route, statusCode, isRscRequest, request, { matchedParams: params });
-        if (fallbackResp) return fallbackResp;
-        setHeadersContext(null);
-        setNavigationContext(null);
-        const statusText = statusCode === 403 ? "Forbidden" : statusCode === 401 ? "Unauthorized" : "Not Found";
-        return new Response(statusText, { status: statusCode });
-      }
-    }
-    return null;
-  }
-
-  // Pre-render layout components to catch notFound()/redirect() thrown from layouts.
-  // In Next.js, each layout level has its own NotFoundBoundary. When a layout throws
-  // notFound(), the parent layout's boundary catches it and renders the parent's
-  // not-found.tsx. Since React Flight doesn't activate client error boundaries during
-  // RSC rendering, we catch layout-level throws here and render the appropriate
-  // fallback page with only the layouts above the throwing one.
-  //
-  // IMPORTANT: Layout pre-render runs BEFORE page pre-render. In Next.js, layouts
-  // render before their children — if a layout throws notFound(), the page never
-  // executes. By checking layouts first, we avoid a bug where the page's notFound()
-  // triggers renderHTTPAccessFallbackPage with ALL route layouts, but one of those
-  // layouts itself throws notFound() during the fallback rendering (causing a 500).
-  if (route.layouts && route.layouts.length > 0) {
-    const asyncParams = makeThenableParams(params);
-    // 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.
-    const _layoutProbeResult = await _suppressHookWarningAls.run(true, async () => {
-      for (let li = route.layouts.length - 1; li >= 0; li--) {
-        const LayoutComp = route.layouts[li]?.default;
-        if (!LayoutComp) continue;
-        try {
-          const lr = LayoutComp({ params: asyncParams, children: null });
-          if (lr && typeof lr === "object" && typeof lr.then === "function") await lr;
-        } catch (layoutErr) {
-          if (layoutErr && typeof layoutErr === "object" && "digest" in layoutErr) {
-            const digest = String(layoutErr.digest);
-             if (digest.startsWith("NEXT_REDIRECT;")) {
-               const parts = digest.split(";");
-               const redirectUrl = decodeURIComponent(parts[2]);
-               const statusCode = parts[3] ? parseInt(parts[3], 10) : 307;
-               setHeadersContext(null);
-               setNavigationContext(null);
-               return Response.redirect(new URL(redirectUrl, request.url), statusCode);
-            }
-            if (digest === "NEXT_NOT_FOUND" || digest.startsWith("NEXT_HTTP_ERROR_FALLBACK;")) {
-              const statusCode = digest === "NEXT_NOT_FOUND" ? 404 : parseInt(digest.split(";")[1], 10);
-              // 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;
-                  }
-                }
+  const _hasLoadingBoundary = !!(route.loading && route.loading.default);
+  const _asyncLayoutParams = makeThenableParams(params);
+  return __renderAppPageLifecycle({
+    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",
+    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() {
+      return PageComponent({ params });
+    },
+    revalidateSeconds,
+    renderErrorBoundaryResponse(renderErr) {
+      return renderErrorBoundaryPage(route, renderErr, isRscRequest, request, params);
+    },
+    async renderLayoutSpecialError(__layoutSpecialError, li) {
+      return __buildAppPageSpecialErrorResponse({
+        clearRequestContext() {
+          setHeadersContext(null);
+          setNavigationContext(null);
+        },
+        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"};
-              // Wrap in only the layouts above the throwing one
-              const parentLayouts = route.layouts.slice(0, li);
-              const fallbackResp = await renderHTTPAccessFallbackPage(
-                route, statusCode, isRscRequest, request,
-                { boundaryComponent: parentNotFound, layouts: parentLayouts, matchedParams: params }
-              );
-              if (fallbackResp) return fallbackResp;
-              setHeadersContext(null);
-              setNavigationContext(null);
-              const statusText = statusCode === 403 ? "Forbidden" : statusCode === 401 ? "Unauthorized" : "Not Found";
-              return new Response(statusText, { status: statusCode });
             }
           }
-          // Not a special error — let it propagate through normal RSC rendering
-        }
-      }
-      return null;
-    });
-    if (_layoutProbeResult instanceof Response) return _layoutProbeResult;
-  }
-
-  // Pre-render the page component to catch redirect()/notFound() thrown synchronously.
-  // Server Components are just functions — we can call PageComponent directly to detect
-  // these special throws before starting the RSC stream.
-  //
-  // For routes with a loading.tsx Suspense boundary, we skip awaiting async components.
-  // The Suspense boundary + rscOnError will handle redirect/notFound thrown during
-  // streaming, and blocking here would defeat streaming (the slow component's delay
-  // would be hit before the RSC stream even starts).
-  //
-  // Because this calls the component outside React's render cycle, hooks like use()
-  // trigger "Invalid hook call" console.error in dev. The module-level ALS patch
-  // suppresses the warning only within this request's execution context.
-  const _hasLoadingBoundary = !!(route.loading && route.loading.default);
-  const _pageProbeResult = await _suppressHookWarningAls.run(true, async () => {
-    try {
-      const testResult = PageComponent({ params });
-      // If it's a promise (async component), only await if there's no loading boundary.
-      // With a loading boundary, the Suspense streaming pipeline handles async resolution
-      // and any redirect/notFound errors via rscOnError.
-      if (testResult && typeof testResult === "object" && typeof testResult.then === "function") {
-        if (!_hasLoadingBoundary) {
-          await testResult;
-        } else {
-          // Suppress unhandled promise rejection — with a loading boundary,
-          // redirect/notFound errors are handled by rscOnError during streaming.
-          testResult.catch(() => {});
-        }
-      }
-    } catch (preRenderErr) {
-      const specialResponse = await handleRenderError(preRenderErr);
-      if (specialResponse) return specialResponse;
-      // Non-special errors from the pre-render test are expected (e.g. use() hook
-      // fails outside React's render cycle, client references can't execute on server).
-      // Only redirect/notFound/forbidden/unauthorized are actionable here — other
-      // errors will be properly caught during actual RSC/SSR rendering below.
-    }
-    return null;
-  });
-  if (_pageProbeResult instanceof Response) return _pageProbeResult;
-
-  // Mark end of compile phase: route matching, middleware, tree building are done.
-  if (process.env.NODE_ENV !== "production") __compileEnd = performance.now();
-
-  // Render to RSC stream.
-  // Track non-navigation RSC errors so we can detect when the in-tree global
-  // ErrorBoundary catches during SSR (producing double <html>/<body>) and
-  // re-render with renderErrorBoundaryPage (which skips layouts for global-error).
-  let _rscErrorForRerender = null;
-  const _baseOnError = createRscOnErrorHandler(request, cleanPathname, route.pattern);
-  const onRenderError = function(error, requestInfo, errorContext) {
-    if (!(error && typeof error === "object" && "digest" in error)) {
-      _rscErrorForRerender = error;
-    }
-    return _baseOnError(error, requestInfo, errorContext);
-  };
-  const rscStream = renderToReadableStream(element, { onError: onRenderError });
-
-  // For ISR pages in production: tee the RSC stream immediately after creation so we
-  // can capture rscData for BOTH RSC requests (client-side nav/prefetch) and HTML
-  // requests. The tee must happen here — before the isRscRequest branch — so both
-  // paths can use the captured bytes when writing to the ISR cache.
-  //   __rscForResponse  → sent to the client (RSC response) or to SSR (HTML response)
-  //   __isrRscDataPromise → resolves to ArrayBuffer of captured RSC wire bytes
-  let __rscForResponse = rscStream;
-  let __isrRscDataPromise = null;
-  if (process.env.NODE_ENV === "production" && revalidateSeconds !== null && revalidateSeconds > 0 && revalidateSeconds !== Infinity && !isForceDynamic) {
-    const [__rscA, __rscB] = rscStream.tee();
-    __rscForResponse = __rscA;
-    __isrRscDataPromise = (async () => {
-      const __rscReader = __rscB.getReader();
-      const __rscChunks = [];
-      let __rscTotal = 0;
-      for (;;) {
-        const { done, value } = await __rscReader.read();
-        if (done) break;
-        __rscChunks.push(value);
-        __rscTotal += value.byteLength;
-      }
-      const __rscBuf = new Uint8Array(__rscTotal);
-      let __rscOff = 0;
-      for (const c of __rscChunks) { __rscBuf.set(c, __rscOff); __rscOff += c.byteLength; }
-      return __rscBuf.buffer;
-    })();
-  }
-
-  if (isRscRequest) {
-    // Direct RSC stream response (for client-side navigation)
-    // NOTE: Do NOT clear headers/navigation context here!
-    // The RSC stream is consumed lazily - components render when chunks are read.
-    // If we clear context now, headers()/cookies() will fail during rendering.
-    // Context will be cleared when the next request starts (via runWithRequestContext).
-    const responseHeaders = { "Content-Type": "text/x-component; charset=utf-8", "Vary": "RSC, Accept" };
-    // Include matched route params so the client can hydrate useParams()
-    if (params && Object.keys(params).length > 0) {
-      responseHeaders["X-Vinext-Params"] = JSON.stringify(params);
-    }
-    if (isForceDynamic) {
-      responseHeaders["Cache-Control"] = "no-store, must-revalidate";
-    } else if ((isForceStatic || isDynamicError) && !revalidateSeconds) {
-      responseHeaders["Cache-Control"] = "s-maxage=31536000, stale-while-revalidate";
-      responseHeaders["X-Vinext-Cache"] = "STATIC";
-    } else if (revalidateSeconds === Infinity) {
-      responseHeaders["Cache-Control"] = "s-maxage=31536000, stale-while-revalidate";
-      responseHeaders["X-Vinext-Cache"] = "STATIC";
-    } else if (revalidateSeconds) {
-      responseHeaders["Cache-Control"] = "s-maxage=" + revalidateSeconds + ", stale-while-revalidate";
-    }
-    // Merge middleware response headers into the RSC response.
-    // set-cookie and vary are accumulated to preserve existing values
-    // (e.g. "Vary: RSC, Accept" set above); all other keys use plain
-    // assignment so middleware headers win over config headers, which
-    // the outer handler applies afterward and skips keys already present.
-    if (_mwCtx.headers) {
-      for (const [key, value] of _mwCtx.headers) {
-        const lk = key.toLowerCase();
-        if (lk === "set-cookie") {
-          const existing = responseHeaders[lk];
-          if (Array.isArray(existing)) {
-            existing.push(value);
-          } else if (existing) {
-            responseHeaders[lk] = [existing, value];
-          } else {
-            responseHeaders[lk] = [value];
-          }
-        } else if (lk === "vary") {
-          // Accumulate Vary values to preserve the existing "RSC, Accept" entry.
-          const existing = responseHeaders["Vary"] ?? responseHeaders["vary"];
-          if (existing) {
-            responseHeaders["Vary"] = existing + ", " + value;
-            if (responseHeaders["vary"] !== undefined) delete responseHeaders["vary"];
-          } else {
-            responseHeaders[key] = value;
-          }
-        } else {
-          responseHeaders[key] = value;
-        }
-      }
-    }
-    // Attach internal timing header so the dev server middleware can log it.
-    // Format: "handlerStart,compileMs,renderMs"
-    //   handlerStart - absolute performance.now() when _handleRequest began,
-    //                  used by the logging middleware to compute true compile
-    //                  time as (handlerStart - middlewareReqStart).
-    //   compileMs    - time inside the handler before renderToReadableStream.
-    //                  -1 sentinel means compile time is not measured.
-    //   renderMs     - -1 sentinel for RSC-only (soft-nav) responses, since
-    //                  rendering is handled asynchronously by the client. The
-    //                  logging middleware computes render time as totalMs - compileMs.
-    if (process.env.NODE_ENV !== "production") {
-      const handlerStart = Math.round(__reqStart);
-      const compileMs = __compileEnd !== undefined ? Math.round(__compileEnd - __reqStart) : -1;
-      responseHeaders["x-vinext-timing"] = handlerStart + "," + compileMs + ",-1";
-    }
-    // For ISR-eligible RSC requests in production: write rscData to its own key.
-    // HTML is stored under a separate key (written by the HTML path below) so
-    // these writes never race or clobber each other.
-    if (process.env.NODE_ENV === "production" && __isrRscDataPromise) {
-      responseHeaders["X-Vinext-Cache"] = "MISS";
-      const __isrKeyRsc = __isrRscKey(cleanPathname);
-      const __revalSecsRsc = revalidateSeconds;
-      const __rscWritePromise = (async () => {
-        try {
-          const __rscDataForCache = await __isrRscDataPromise;
-          const __pageTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
-          await __isrSet(__isrKeyRsc, { kind: "APP_PAGE", html: "", rscData: __rscDataForCache, headers: undefined, postponed: undefined, status: 200 }, __revalSecsRsc, __pageTags);
-          __isrDebug?.("RSC cache written", __isrKeyRsc);
-        } catch (__rscWriteErr) {
-          console.error("[vinext] ISR RSC cache write error:", __rscWriteErr);
-        }
-      })();
-      _getRequestExecutionContext()?.waitUntil(__rscWritePromise);
-    }
-    return new Response(__rscForResponse, { status: _mwCtx.status || 200, headers: responseHeaders });
-  }
-
-  // Collect font data from RSC environment before passing to SSR
-  // (Fonts are loaded during RSC rendering when layout.tsx calls Geist() etc.)
-  const fontData = {
-    links: _getSSRFontLinks(),
-    styles: _getSSRFontStyles(),
-    preloads: _getSSRFontPreloads(),
-  };
-
-  // Build HTTP Link header for font preloading.
-  // This lets the browser (and CDN) start fetching font files before parsing HTML,
-  // eliminating the CSS → woff2 download waterfall.
-  const fontPreloads = fontData.preloads || [];
-  const fontLinkHeaderParts = [];
-  for (const preload of fontPreloads) {
-    fontLinkHeaderParts.push("<" + preload.href + ">; rel=preload; as=font; type=" + preload.type + "; crossorigin");
-  }
-  const fontLinkHeader = fontLinkHeaderParts.length > 0 ? fontLinkHeaderParts.join(", ") : "";
-
-  // __rscForResponse was already teed above (before isRscRequest) for ISR pages in
-  // production. For non-ISR or dev, __rscForResponse === rscStream (no tee).
-  // __isrRscDataPromise resolves to rscData bytes used by the RSC write path above;
-  // the HTML write path below uses its own separate key and does not need rscData.
-
-  // Delegate to SSR environment for HTML rendering
-  let htmlStream;
-  try {
-    const ssrEntry = await import.meta.viteRsc.loadModule("ssr", "index");
-    htmlStream = await ssrEntry.handleSsr(__rscForResponse, _getNavigationContext(), fontData);
-    // Shell render complete; Suspense boundaries stream asynchronously
-    if (process.env.NODE_ENV !== "production") __renderEnd = performance.now();
-  } catch (ssrErr) {
-    const specialResponse = await handleRenderError(ssrErr);
-    if (specialResponse) return specialResponse;
-    // Non-special error during SSR — render error.tsx if available
-    const errorBoundaryResp = await renderErrorBoundaryPage(route, ssrErr, isRscRequest, request, params);
-    if (errorBoundaryResp) return errorBoundaryResp;
-    throw ssrErr;
-  }
-
-  // If an RSC error was caught by the in-tree global ErrorBoundary during SSR,
-  // the HTML output has double <html>/<body> (root layout + global-error.tsx).
-  // Discard it and re-render using renderErrorBoundaryPage which skips layouts
-  // when the error falls through to global-error.tsx.
-  ${globalErrorVar ? `
-  if (_rscErrorForRerender && !isRscRequest) {
-    const _hasLocalBoundary = !!(route?.error?.default) || !!(route?.errors && route.errors.some(function(e) { return e?.default; }));
-    if (!_hasLocalBoundary) {
-      const cleanResp = await renderErrorBoundaryPage(route, _rscErrorForRerender, false, request, params);
-      if (cleanResp) return cleanResp;
-    }
-  }
-  ` : ""}
-
-  // Check for draftMode Set-Cookie header (from draftMode().enable()/disable())
-  const draftCookie = getDraftModeCookieHeader();
-
-  setHeadersContext(null);
-  setNavigationContext(null);
-
-  // Helper to attach draftMode cookie, middleware headers, font Link header, and rewrite status to a response
-  function attachMiddlewareContext(response) {
-    if (draftCookie) {
-      response.headers.append("Set-Cookie", draftCookie);
-    }
-    // Set HTTP Link header for font preloading
-    if (fontLinkHeader) {
-      response.headers.set("Link", fontLinkHeader);
-    }
-    // Merge middleware response headers into the final response.
-    // The response is freshly constructed above (new Response(htmlStream, {...})),
-    // so set() and append() are equivalent — there are no same-key conflicts yet.
-    // Precedence over config headers is handled by the outer handler, which
-    // skips config keys that middleware already placed on the response.
-    if (_mwCtx.headers) {
-      for (const [key, value] of _mwCtx.headers) {
-        response.headers.append(key, value);
-      }
-    }
-    // Attach internal timing header so the dev server middleware can log it.
-    // Format: "handlerStart,compileMs,renderMs"
-    //   handlerStart - absolute performance.now() when _handleRequest began,
-    //                  used by the logging middleware to compute true compile
-    //                  time as (handlerStart - middlewareReqStart).
-    //   compileMs    - time inside the handler before renderToReadableStream.
-    //   renderMs     - time from renderToReadableStream to handleSsr completion,
-    //                  or -1 sentinel if not measured (falls back to totalMs - compileMs).
-    if (process.env.NODE_ENV !== "production") {
-      const handlerStart = Math.round(__reqStart);
-      const compileMs = __compileEnd !== undefined ? Math.round(__compileEnd - __reqStart) : -1;
-      const renderMs = __renderEnd !== undefined && __compileEnd !== undefined
-        ? Math.round(__renderEnd - __compileEnd)
-        : -1;
-      response.headers.set("x-vinext-timing", handlerStart + "," + compileMs + "," + renderMs);
-    }
-    // Apply custom status code from middleware rewrite
-    if (_mwCtx.status) {
-      return new Response(response.body, {
-        status: _mwCtx.status,
-        headers: response.headers,
+          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,
+          });
+        },
+        requestUrl: request.url,
+        specialError: __layoutSpecialError,
       });
-    }
-    return response;
-  }
-
-  // Check if any component called connection(), cookies(), headers(), or noStore()
-  // during rendering. If so, treat as dynamic (skip ISR, set no-store).
-  const dynamicUsedDuringRender = consumeDynamicUsage();
-
-  // Check if cacheLife() was called during rendering (e.g., page with file-level "use cache").
-  // If so, use its revalidation period for the Cache-Control header.
-  const requestCacheLife = _consumeRequestScopedCacheLife();
-  if (requestCacheLife && requestCacheLife.revalidate !== undefined && revalidateSeconds === null) {
-    revalidateSeconds = requestCacheLife.revalidate;
-  }
-
-  // force-dynamic: always return no-store (highest priority)
-  if (isForceDynamic) {
-    return attachMiddlewareContext(new Response(htmlStream, {
-      headers: {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "no-store, must-revalidate",
-        "Vary": "RSC, Accept",
-      },
-    }));
-  }
-
-  // force-static / error: treat as static regardless of dynamic usage.
-  // force-static intentionally provides empty headers/cookies context so
-  // dynamic APIs return safe defaults; we ignore the dynamic usage signal.
-  // dynamic='error' should have already thrown via the request API accessError
-  // trap if user code touched a dynamic API, so reaching here means rendering succeeded.
-  if ((isForceStatic || isDynamicError) && (revalidateSeconds === null || revalidateSeconds === 0)) {
-    return attachMiddlewareContext(new Response(htmlStream, {
-      headers: {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "s-maxage=31536000, stale-while-revalidate",
-        "X-Vinext-Cache": "STATIC",
-        "Vary": "RSC, Accept",
-      },
-    }));
-  }
-
-  // auto mode: dynamic API usage (headers(), cookies(), connection(), noStore(),
-  // searchParams access) opts the page into dynamic rendering with no-store.
-  if (dynamicUsedDuringRender) {
-    return attachMiddlewareContext(new Response(htmlStream, {
-      headers: {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "no-store, must-revalidate",
-        "Vary": "RSC, Accept",
-      },
-    }));
-  }
-
-  // Emit Cache-Control for ISR pages and write to ISR cache on MISS (production only).
-  // revalidate=Infinity means "cache forever" (no periodic revalidation) — treated as
-  // static here so we emit s-maxage=31536000 but skip ISR cache management.
-  if (revalidateSeconds !== null && revalidateSeconds > 0 && revalidateSeconds !== Infinity) {
-    // In production, tee the HTML response body to simultaneously stream to the
-    // client and collect the full HTML string for the ISR cache. rscData was
-    // already captured above by teeing the RSC stream before SSR.
-    // In dev, skip the tee and the X-Vinext-Cache header — every request renders
-    // fresh (no cache reads or writes in dev mode).
-    if (process.env.NODE_ENV === "production") {
-      const __isrResponseProd = attachMiddlewareContext(new Response(htmlStream, {
-        headers: {
-          "Content-Type": "text/html; charset=utf-8",
-          "Cache-Control": "s-maxage=" + revalidateSeconds + ", stale-while-revalidate",
-          "Vary": "RSC, Accept",
-          "X-Vinext-Cache": "MISS",
+    },
+    async renderPageSpecialError(specialError) {
+      return __buildAppPageSpecialErrorResponse({
+        clearRequestContext() {
+          setHeadersContext(null);
+          setNavigationContext(null);
         },
-      }));
-      if (__isrResponseProd.body) {
-        const [__streamForClient, __streamForCache] = __isrResponseProd.body.tee();
-        const __isrKey = __isrHtmlKey(cleanPathname);
-        const __isrKeyRscFromHtml = __isrRscKey(cleanPathname);
-        const __revalSecs = revalidateSeconds;
-        const __capturedRscDataPromise = __isrRscDataPromise;
-        const __cachePromise = (async () => {
-          try {
-            const __reader = __streamForCache.getReader();
-            const __decoder = new TextDecoder();
-            const __chunks = [];
-            for (;;) {
-              const { done, value } = await __reader.read();
-              if (done) break;
-              __chunks.push(__decoder.decode(value, { stream: true }));
-            }
-            __chunks.push(__decoder.decode());
-            const __fullHtml = __chunks.join("");
-            const __pageTags = __pageCacheTags(cleanPathname, getCollectedFetchTags());
-            // Write HTML and RSC to their own keys independently.
-            // RSC data was captured by the tee above (before isRscRequest branch)
-            // so an initial browser visit (HTML request) also populates the RSC key,
-            // ensuring the first client-side navigation after a direct visit is a
-            // cache hit rather than a miss.
-            const __writes = [
-              __isrSet(__isrKey, { kind: "APP_PAGE", html: __fullHtml, rscData: undefined, headers: undefined, postponed: undefined, status: 200 }, __revalSecs, __pageTags),
-            ];
-            if (__capturedRscDataPromise) {
-              __writes.push(
-                __capturedRscDataPromise.then((__rscBuf) =>
-                  __isrSet(__isrKeyRscFromHtml, { kind: "APP_PAGE", html: "", rscData: __rscBuf, headers: undefined, postponed: undefined, status: 200 }, __revalSecs, __pageTags)
-                )
-              );
-            }
-            await Promise.all(__writes);
-            __isrDebug?.("HTML cache written", __isrKey);
-          } catch (__cacheErr) {
-            console.error("[vinext] ISR cache write error:", __cacheErr);
-          }
-        })();
-        // Register with ExecutionContext (from ALS) so the Workers runtime keeps
-        // the isolate alive until the cache write finishes, even after the response is sent.
-        _getRequestExecutionContext()?.waitUntil(__cachePromise);
-        return new Response(__streamForClient, { status: __isrResponseProd.status, headers: __isrResponseProd.headers });
-      }
-      return __isrResponseProd;
-    }
-    // Dev mode: return Cache-Control header but no X-Vinext-Cache (no cache read/write)
-    return attachMiddlewareContext(new Response(htmlStream, {
-      headers: {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "s-maxage=" + revalidateSeconds + ", stale-while-revalidate",
-        "Vary": "RSC, Accept",
-      },
-    }));
-  }
-
-  // revalidate=Infinity (or false, which Next.js normalises to false/0): treat as
-  // permanent static — emit the longest safe s-maxage but skip ISR cache management.
-  if (revalidateSeconds === Infinity) {
-    return attachMiddlewareContext(new Response(htmlStream, {
-      headers: {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "s-maxage=31536000, stale-while-revalidate",
-        "X-Vinext-Cache": "STATIC",
-        "Vary": "RSC, Accept",
-      },
-    }));
-  }
-
-  return attachMiddlewareContext(new Response(htmlStream, {
-    headers: { "Content-Type": "text/html; charset=utf-8", "Vary": "RSC, Accept" },
-  }));
+        renderFallbackPage(statusCode) {
+          return renderHTTPAccessFallbackPage(route, statusCode, isRscRequest, request, {
+            matchedParams: params,
+          });
+        },
+        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);
+    },
+    waitUntil(__cachePromise) {
+      _getRequestExecutionContext()?.waitUntil(__cachePromise);
+    },
+  });
 }
 
 if (import.meta.hot) {