vinext 1.2.1 → 1.3.1

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

@@ -6,8 +6,8 @@ import { extractExportConstString, getAppRouteRenderEntryPath } from "../build/r
 import { routePatternParts } from "../routing/route-pattern.js";
 import { safeJsonStringify } from "../server/html.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES } from "../server/image-optimization.js";
-import { buildAppRscManifestCode } from "./app-rsc-manifest.js";
 import { classifyAppPageRouteStaticEligibility } from "../build/app-page-static-eligibility.js";
+import { buildAppRscManifestCode } from "./app-rsc-manifest.js";
 import { generateDevOriginCheckCode } from "../server/dev-origin-check.js";
 import { ACTION_OWNER_MANIFEST_ID } from "../plugins/action-owner-manifest.js";
 import fs from "node:fs";
@@ -46,11 +46,13 @@ const appPageRequestPath = resolveEntryPath("../server/app-page-request.js", imp
 const appSegmentConfigPath = resolveEntryPath("../server/app-segment-config.js", import.meta.url);
 const appRscRouteMatchingPath = resolveEntryPath("../server/app-rsc-route-matching.js", import.meta.url);
 const appRscResponseStagePath = resolveEntryPath("../server/app-rsc-response-stage.js", import.meta.url);
-const rscStreamHintsPath = resolveEntryPath("../server/rsc-stream-hints.js", import.meta.url);
+const rscRenderStreamPath = resolveEntryPath("../server/rsc-render-stream.js", import.meta.url);
+const appClientReferenceManifestPath = resolveEntryPath("../server/app-client-reference-manifest.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 isolateSharedPromisePath = resolveEntryPath("../server/isolate-shared-promise.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 appRequestStageContextPath = resolveEntryPath("../server/app-request-stage-context.js", import.meta.url);
@@ -116,19 +118,22 @@ function buildAppDecodedPathnamePatterns(routes, config) {
 	};
 	return routes.filter((route) => !route.isDynamic && !route.routePath && getAppRouteRenderEntryPath(route) !== null && isPrerenderedPage(route)).map((route) => route.pattern);
 }
-function buildAppRequestRouteMetadata(routes) {
+function createForcesDynamicReader() {
 	const readSource = createSegmentSourceReader();
-	const forcesDynamic = (filePath) => {
+	return (filePath) => {
 		const source = readSource(filePath);
 		return source !== null && extractExportConstString(source, "dynamic") === "force-dynamic";
 	};
+}
+/** Whether a direct request to the route renders a `dynamic = "force-dynamic"` tree. */
+function directRequestForcesDynamic(route, forcesDynamic) {
+	return route.routePath ? forcesDynamic(route.routePath) : appPageSegmentConfigPaths(route).some(forcesDynamic);
+}
+function buildAppRequestRouteMetadata(routes) {
+	const forcesDynamic = createForcesDynamicReader();
 	return routes.map((route) => ({
 		canUseCanonicalLoadingShell: appRouteHasMainTreeLoadingBoundary(route),
-		forceDynamic: route.routePath ? forcesDynamic(route.routePath) : [
-			...appPageSegmentConfigPaths(route),
-			...route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.flatMap((intercept) => [...intercept.layoutPaths, intercept.pagePath])),
-			...route.siblingIntercepts.flatMap((intercept) => [...intercept.layoutPaths, intercept.pagePath])
-		].some(forcesDynamic),
+		forceDynamic: directRequestForcesDynamic(route, forcesDynamic) || [...route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.flatMap((intercept) => [...intercept.layoutPaths, intercept.pagePath])), ...route.siblingIntercepts.flatMap((intercept) => [...intercept.layoutPaths, intercept.pagePath])].some(forcesDynamic),
 		ids: route.ids ?? null,
 		pattern: route.pattern,
 		patternParts: route.patternParts,
@@ -153,10 +158,18 @@ function buildAppRequestRouteMetadata(routes) {
 				interceptBranchSegments: intercept.branchSegments ?? [],
 				interceptLoadings: [],
 				interceptLoadingTreePositions: intercept.loadingTreePositions ?? [],
+				interceptNotFounds: [],
+				interceptNotFoundTreePositions: intercept.notFoundTreePositions ?? [],
 				interceptNotFoundBranchSegments: intercept.notFoundBranchSegments ?? intercept.branchSegments ?? [],
 				page: null,
 				notFound: null,
 				notFoundTreePosition: intercept.notFoundTreePosition ?? null,
+				interceptForbiddens: [],
+				interceptForbiddenTreePositions: intercept.forbiddenTreePositions ?? [],
+				interceptUnauthorizeds: [],
+				interceptUnauthorizedTreePositions: intercept.unauthorizedTreePositions ?? [],
+				interceptErrors: [],
+				interceptErrorTreePositions: intercept.errorTreePositions ?? [],
 				params: intercept.params
 			}))
 		}])),
@@ -171,14 +184,45 @@ function buildAppRequestRouteMetadata(routes) {
 			interceptBranchSegments: intercept.branchSegments ?? [],
 			interceptLoadings: [],
 			interceptLoadingTreePositions: intercept.loadingTreePositions ?? [],
+			interceptNotFounds: [],
+			interceptNotFoundTreePositions: intercept.notFoundTreePositions ?? [],
 			interceptNotFoundBranchSegments: intercept.notFoundBranchSegments ?? intercept.branchSegments ?? [],
 			page: null,
 			notFound: null,
 			notFoundTreePosition: intercept.notFoundTreePosition ?? null,
+			interceptForbiddens: [],
+			interceptForbiddenTreePositions: intercept.forbiddenTreePositions ?? [],
+			interceptUnauthorizeds: [],
+			interceptUnauthorizedTreePositions: intercept.unauthorizedTreePositions ?? [],
+			interceptErrors: [],
+			interceptErrorTreePositions: intercept.errorTreePositions ?? [],
 			params: intercept.params
 		}))
 	}));
 }
+/**
+* Register the build-time route facts `revalidatePath()` uses to skip CDN
+* purges for force-dynamic routes. A Pages Router can serve the same paths
+* without those facts, so mixed apps always purge.
+*/
+function generateCdnPurgeRoutesRegistration(routes, metadataRoutes, config) {
+	if (config?.hasPagesDir) return "";
+	const forcesDynamic = createForcesDynamicReader();
+	const purgeRoutes = {
+		metadataRoutes: (metadataRoutes ?? []).map((route) => ({
+			patternParts: route.patternParts ?? null,
+			routeSegments: route.routeSegments ?? [],
+			servedUrl: route.servedUrl
+		})),
+		routes: routes.map((route) => ({
+			forceDynamic: directRequestForcesDynamic(route, forcesDynamic),
+			patternParts: route.patternParts,
+			routeSegments: route.routeSegments
+		}))
+	};
+	return `import { registerCdnPurgeRoutes as __registerCdnPurgeRoutes } from "vinext/shims/cdn-purge-routes";
+__registerCdnPurgeRoutes(${JSON.stringify(purgeRoutes)});`;
+}
 /** Generate the module-free App request stage used by multi-stage Worker outputs. */
 function generateAppRequestRscEntry(appDir, routes, middlewarePath, metadataRoutes, _globalErrorPath, basePath, trailingSlash, config, instrumentationPath) {
 	const bp = basePath ?? "";
@@ -204,13 +248,14 @@ import __pagesClientAssets from "virtual:vinext-pages-client-assets";
 ${middlewarePath ? `import { applyAppMiddleware as __applyAppMiddleware } from ${JSON.stringify(appMiddlewarePath)};` : ""}
 ${instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(toSlash(instrumentationPath))};
 import { ensureInstrumentationRegistered as __ensureInstrumentationRegistered } from ${JSON.stringify(instrumentationRuntimePath)};
+import { shareIsolatePromise as __shareIsolatePromise } from ${JSON.stringify(isolateSharedPromisePath)};
 let __applicationInitialization;
 async function __initializeApplication() {
   await __ensureInstrumentationRegistered(_instrumentation, ${JSON.stringify(toSlash(instrumentationPath))});
   ${middlewarePath ? `middlewareModule = await import(${JSON.stringify(toSlash(middlewarePath))});` : ""}
 }
-export function __ensureInstrumentation() {
-  return __applicationInitialization ??= __initializeApplication();
+export function __ensureInstrumentation(ctx) {
+  return __applicationInitialization ??= __shareIsolatePromise(__initializeApplication(), ctx);
 }` : "export function __ensureInstrumentation() {}"}
 ${middlewarePath ? instrumentationPath ? "let middlewareModule;" : `import * as middlewareModule from ${JSON.stringify(toSlash(middlewarePath))};` : ""}
 ${hasPagesDir ? `import { getDraftModeCookieHeader } from "next/headers";
@@ -219,8 +264,8 @@ import { renderPagesFallback as __renderPagesFallback } from ${JSON.stringify(ap
 import { buildRequestHeadersFromMiddlewareResponse as __buildRequestHeadersFromMiddlewareResponse } from ${JSON.stringify(middlewareRequestHeadersPath)};
 import { applyRouteHandlerMiddlewareContext as __applyRouteHandlerMiddlewareContext } from ${JSON.stringify(appRouteHandlerMiddlewareContextPath)};` : ""}
 
-${hasPagesDir ? `export function __ensureHybridPagesApplication() {
-  return __pagesRequestEntry.__ensureInstrumentation?.();
+${hasPagesDir ? `export function __ensureHybridPagesApplication(ctx) {
+  return __pagesRequestEntry.__ensureInstrumentation?.(ctx);
 }` : "export function __ensureHybridPagesApplication() {}"}
 
 const __basePath = ${JSON.stringify(bp)};
@@ -242,6 +287,7 @@ export const __clientBuildFiles = __pagesClientAssets.clientBuildFiles ?? [];
 const __routes = ${JSON.stringify(requestRoutes)};
 const __routeMatcher = __createAppRscRouteMatcher(__routes, ${JSON.stringify(buildAppDecodedPathnamePatterns(routes, config))});
 const __metadataRouteMatchers = ${JSON.stringify(metadataRouteMatchers)};
+${generateCdnPurgeRoutesRegistration(routes, metadataRoutes, config)}
 
 function matchRoute(pathname) { return __routeMatcher.matchRoute(pathname); }
 function matchRequestRoute(pathname) { return __routeMatcher.matchRequestRoute(pathname); }
@@ -295,7 +341,7 @@ const __requestHandler = createAppRscRequestHandler({
   devForwardedMiddlewareContextKey: ${JSON.stringify(config?.devForwardedMiddlewareContextKey ?? null)},
   dispatchMatchedPage() { throw new Error("App request stage attempted to render a page inline"); },
   dispatchMatchedRouteHandler() { throw new Error("App request stage attempted to render a route handler inline"); },
-  ${instrumentationPath ? "ensureInstrumentation() { return __ensureInstrumentation(); }," : ""}
+  ${instrumentationPath ? "ensureInstrumentation(ctx) { return __ensureInstrumentation(ctx); }," : ""}
   i18nConfig: ${JSON.stringify(config?.i18n ?? null)},
   imageConfig: ${JSON.stringify(config?.imageConfig)},
   isMetadataRoute: __isMetadataPath,
@@ -368,6 +414,7 @@ const __requestHandler = createAppRscRequestHandler({
   },` : ""}
   rootParamNamesByPattern: {},
   setNavigationContext,
+  skipProxyUrlNormalize: ${JSON.stringify(config?.skipProxyUrlNormalize ?? false)},
   skipTrailingSlashRedirect: ${JSON.stringify(config?.skipTrailingSlashRedirect ?? false)},
   staticParamsMap: {},
   trailingSlash: __trailingSlash,
@@ -449,12 +496,12 @@ function generateRscEntry(appDir, routes, middlewarePath, metadataRoutes, global
 	});
 	const loadPrerenderPagesRoutesCode = hasPagesDir ? `
 let __hybridPagesApplication;
-export function __ensureHybridPagesApplication() {
-  return __hybridPagesApplication ??= (async () => {
+export function __ensureHybridPagesApplication(ctx) {
+  return __hybridPagesApplication ??= __shareIsolatePromise((async () => {
     const __pagesEntry = await import.meta.viteRsc.loadModule("ssr", "index");
-    await __pagesEntry.__ensureInstrumentation?.();
+    await __pagesEntry.__ensureInstrumentation?.(ctx);
     return __pagesEntry;
-  })();
+  })(), ctx);
 }
 async function __loadPrerenderPagesRoutes() {
   const __gspSsrEntry = await __ensureHybridPagesApplication();
@@ -475,8 +522,8 @@ ${metaRouteEntries.join(",\n")}
   rootLayouts = [${rootLayoutVars.join(", ")}];
   __fallbackRenderer = __createFallbackRenderer();
 }
-export function __ensureInstrumentation() {
-  return __applicationInitialization ??= __initializeApplication();
+export function __ensureInstrumentation(ctx) {
+  return __applicationInitialization ??= __shareIsolatePromise(__initializeApplication(), ctx);
 }` : "export function __ensureInstrumentation() {}";
 	return `
 ${hasAppRouteHandlers ? `// Capture the canonical Request surface before any user module can extend it.
@@ -485,26 +532,37 @@ import ${JSON.stringify(appRouteRequestBuiltInsPath)};` : ""}
 import ${JSON.stringify(serverGlobalsPath)};
 import __cacheabilityManifest from "virtual:vinext-cacheability-manifest";
 export { __cacheabilityManifest };
-import {
-  renderToReadableStream as _renderToReadableStream,
-  ${hasServerActions ? `decodeAction,
-  decodeFormState,
-  decodeReply,
-  loadServerAction,
-  createTemporaryReferenceSet,` : ""}
-} from ${JSON.stringify(hasServerActions ? "@vitejs/plugin-rsc/rsc" : "@vitejs/plugin-rsc/react/rsc")};
-import { createClientManifest as _createClientManifest } from "@vitejs/plugin-rsc/core/rsc";
+${hasServerActions ? `import { loadServerAction, createTemporaryReferenceSet } from "@vitejs/plugin-rsc/rsc";\n` : ""}import {
+  createClientManifest as _createClientManifest,${hasServerActions ? `
+  createServerManifest as _createServerManifest,` : ""}
+} from "@vitejs/plugin-rsc/core/rsc";
+import { renderToReadableStream as _renderToReadableStream } from "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge";
 import { prerender as _prerender } from "@vitejs/plugin-rsc/vendor/react-server-dom/static.edge";
-import { createRscPrerenderer, createRscRenderer } from ${JSON.stringify(rscStreamHintsPath)};
+import { createClientReferenceChunksManifest } from ${JSON.stringify(appClientReferenceManifestPath)};
+${hasServerActions ? `// plugin-rsc's decoders fix an unscoped server manifest; React's own take the
+// manifest, so actions can scope the server references they decode per route.
+import {
+  decodeAction as _decodeAction,
+  decodeFormState as _decodeFormState,
+  decodeReply as _decodeReply,
+} from "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge";
+` : ""}import { createRscRenderer } from ${JSON.stringify(rscRenderStreamPath)};
 
-const renderToReadableStream = createRscRenderer(_renderToReadableStream);
-const prerenderToReadableStream = createRscPrerenderer(async (model, options) =>
-  _prerender(model, _createClientManifest(), options),
+// Each render takes a fresh client manifest: in development, its references
+// carry a new cache tag.
+const __withClientReferenceChunks = createClientReferenceChunksManifest(
+  __pagesClientAssets.appClientReferenceChunks,
+);
+const renderToReadableStream = createRscRenderer((model, options) =>
+  _renderToReadableStream(model, __withClientReferenceChunks(_createClientManifest()), options),
 );
+const prerenderToReadableStream = (model, options) =>
+  _prerender(model, __withClientReferenceChunks(_createClientManifest()), options);
 import { createElement } from "react";
 import { getNavigationContext as _getNavigationContext } from "next/navigation";
 import { configureMemoryCacheHandler as __configureMemoryCacheHandler } from "vinext/shims/cache-handler";
 import { getRequestExecutionContext as __getRequestExecutionContext } from "vinext/shims/request-context";
+import { shareIsolatePromise as __shareIsolatePromise } from ${JSON.stringify(isolateSharedPromisePath)};
 import { headersContextFromRequest, getDraftModeCookieHeader, getAndClearPendingCookies, consumeDynamicUsage, consumeInvalidDynamicUsageError, setHeadersAccessPhase } from "next/headers";
 import { mergeMetadata, resolveModuleMetadata, mergeViewport, resolveModuleViewport } from "vinext/metadata";
 ${config?.nodeOpenTelemetryLoader ? `import { register as __registerOpenTelemetryLoader } from "node:module";
@@ -878,6 +936,8 @@ function __createFallbackRenderer() {
 }
 ${instrumentationPath ? "let __fallbackRenderer;" : "const __fallbackRenderer = __createFallbackRenderer();"}
 
+${generateCdnPurgeRoutesRegistration(routes, metadataRoutes, config)}
+
 function matchRoute(url) {
   return __routeMatcher.matchRoute(url);
 }
@@ -1093,9 +1153,11 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
           observeMetadataSearchParamsAccess: buildOptions?.observeMetadataSearchParamsAccess === true,
           observePageSearchParamsAccess: buildOptions?.observePageSearchParamsAccess === true,
           isForceStatic: buildOptions?.isForceStatic === true,
+          isUncacheableRender: buildOptions?.isUncacheableRender === true,
           serveStreamingMetadata: buildOptions?.serveStreamingMetadata,
           placeStreamedMetadataInHead: buildOptions?.placeStreamedMetadataInHead === true,
           isProduction: process.env.NODE_ENV === "production",
+          onHeadPrepared: buildOptions?.onHeadPrepared,
         }, layoutParamAccess, displayPathname, scriptNonce);
       },
       clientReuseManifest,
@@ -1286,8 +1348,8 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
       searchParams,
     });
   },
-  ${instrumentationPath ? `ensureInstrumentation() {
-    return __ensureInstrumentation();
+  ${instrumentationPath ? `ensureInstrumentation(ctx) {
+    return __ensureInstrumentation(ctx);
   },` : ""}
   ${hasServerActions ? `
   async handleProgressiveActionRequest({
@@ -1305,13 +1367,15 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
     } = await __loadAppServerActionExecution();
     const {
       areServerActionsOwnedByRoute: __areServerActionsOwnedByRoute,
+      createForwardedActionContext: __createForwardedActionContext,
       forwardServerActionIfNeeded: __forwardServerActionIfNeeded,
     } = await __loadAppActionForwarding();
     // A multipart form POST to a page is always a server-action attempt, so a
     // body that decodes to no action must surface as 404 action-not-found
-    // (#1340). Route handlers run after this dispatch and accept raw multipart
-    // POSTs, so only flag actual page routes. The __loadPage / __loadRouteHandler
-    // markers are static and available before lazy module hydration.
+    // (#1340). Route handlers and Pages routes never reach this dispatch
+    // (#3886) and unmatched routes fall through, so only flag page routes.
+    // The __loadPage marker is static and available before lazy module
+    // hydration.
     //
     // Only the progressive (multipart, no actionId) POST path consults
     // hasPageRoute, so skip the route match entirely for every other request
@@ -1321,11 +1385,7 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
       contentType,
       actionId,
     );
-    const __hasPageRoute = Boolean(
-      __isProgressiveAction &&
-        routeMatch?.route.__loadPage &&
-        !routeMatch.route.__loadRouteHandler,
-    );
+    const __hasPageRoute = Boolean(__isProgressiveAction && routeMatch?.route.__loadPage);
     return __handleProgressiveServerActionRequest({
       actionId,
       allowedOrigins: __allowedOrigins,
@@ -1335,8 +1395,9 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
         __clearRequestContext();
       },
       contentType,
-      decodeAction,
-      decodeFormState,
+      createServerManifest: _createServerManifest,
+      decodeAction: _decodeAction,
+      decodeFormState: _decodeFormState,
       getAndClearPendingCookies,
       getDraftModeCookieHeader,
       forwardAction(__progressiveActionId) {
@@ -1348,17 +1409,9 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
           clearRequestContext: __clearRequestContext,
           currentRoutePattern: routeMatch?.route.pattern ?? null,
           dispatch(__forwardRequest) {
-            const __executionContext = __getRequestExecutionContext();
             return __appRscHandler(
               __forwardRequest,
-              __executionContext
-                ? {
-                    actionForwarded: true,
-                    cache: __executionContext.cache,
-                    passThroughOnException: __executionContext.passThroughOnException?.bind(__executionContext),
-                    waitUntil: __executionContext.waitUntil.bind(__executionContext),
-                  }
-                : { actionForwarded: true },
+              __createForwardedActionContext(__getRequestExecutionContext()),
             );
           },
           middlewareContext,
@@ -1398,8 +1451,11 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
     sourceConfigHeaders,
     searchParams,
   }) {
-    const { forwardServerActionIfNeeded: __forwardServerActionIfNeeded } =
-      await __loadAppActionForwarding();
+    const {
+      areServerActionsOwnedByRoute: __areServerActionsOwnedByRoute,
+      createForwardedActionContext: __createForwardedActionContext,
+      forwardServerActionIfNeeded: __forwardServerActionIfNeeded,
+    } = await __loadAppActionForwarding();
     const __currentActionMatch = routeMatch;
     const __forwardResponse = await __forwardServerActionIfNeeded({
       actionId,
@@ -1409,17 +1465,9 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
       clearRequestContext: __clearRequestContext,
       currentRoutePattern: __currentActionMatch?.route.pattern ?? null,
       dispatch(__forwardRequest) {
-        const __executionContext = __getRequestExecutionContext();
         return __appRscHandler(
           __forwardRequest,
-          __executionContext
-            ? {
-                actionForwarded: true,
-                cache: __executionContext.cache,
-                passThroughOnException: __executionContext.passThroughOnException?.bind(__executionContext),
-                waitUntil: __executionContext.waitUntil.bind(__executionContext),
-              }
-            : { actionForwarded: true },
+          __createForwardedActionContext(__getRequestExecutionContext()),
         );
       },
       middlewareContext,
@@ -1492,8 +1540,9 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
       createRscOnErrorHandler(actionRequest, actionPathname, routePattern, overrides) {
         return createRscOnErrorHandler(actionRequest, actionPathname, routePattern, overrides);
       },
+      createServerManifest: _createServerManifest,
       createTemporaryReferenceSet,
-      decodeReply,
+      decodeReply: _decodeReply,
       dispatchRedirectRequest(redirectRequest) {
         return __appRscHandler(redirectRequest, undefined);
       },
@@ -1511,6 +1560,13 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
       },
       isRscRequest,
       loadServerAction,
+      validateActionReferences(__argumentActionIds) {
+        return __areServerActionsOwnedByRoute(
+          __VINEXT_ACTION_OWNERS(),
+          __argumentActionIds,
+          __actionMatch?.route.pattern ?? null,
+        );
+      },
       // Redirect targets are rendered as if the client had navigated to them,
       // so they must route on the raw pathname a real request would use.
       matchRoute(pathnameToMatch) {
@@ -1556,6 +1612,14 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
           interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
           interceptNotFound: intercept.notFound,
           interceptNotFoundTreePosition: intercept.notFoundTreePosition,
+          interceptForbiddens: intercept.interceptForbiddens,
+          interceptForbiddenTreePositions: intercept.interceptForbiddenTreePositions,
+          interceptUnauthorizeds: intercept.interceptUnauthorizeds,
+          interceptUnauthorizedTreePositions: intercept.interceptUnauthorizedTreePositions,
+          interceptErrors: intercept.interceptErrors,
+          interceptErrorTreePositions: intercept.interceptErrorTreePositions,
+          interceptNotFounds: intercept.interceptNotFounds,
+          interceptNotFoundTreePositions: intercept.interceptNotFoundTreePositions,
           interceptSlotId: intercept.slotId,
           interceptSlotKey: intercept.slotKey,
           interceptSourceMatchedUrl: interceptionContext,
@@ -1676,6 +1740,7 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
   },` : ""}
   rootParamNamesByPattern: rootParamNamesMap,
   setNavigationContext,
+  skipProxyUrlNormalize: ${JSON.stringify(config?.skipProxyUrlNormalize ?? false)},
   skipTrailingSlashRedirect: ${JSON.stringify(config?.skipTrailingSlashRedirect ?? false)},
   staticParamsMap: generateStaticParamsMap,
   trailingSlash: __trailingSlash,

package/dist/entries/app-rsc-manifest.d.ts

@@ -49,5 +49,16 @@ type BuildAppRscManifestCodeOptions = {
    */
   globalNotFoundPath?: string | null;
 };
+/**
+ * The root not-found, forbidden and unauthorized boundaries, which a route
+ * without its own boundary falls back to.
+ */
+export declare function rootBoundaryFiles(routes: readonly AppRoute[]): string[];
+/**
+ * The files a render without a matched route shows (a route-miss 404, or a
+ * forbidden or unauthorized boundary): the root layouts and root boundaries.
+ */
+export declare function rootBoundaryRouteFiles(routes: readonly AppRoute[]): string[];
 export declare function buildAppRscManifestCode(options: BuildAppRscManifestCodeOptions): AppRscManifestCode;
-//#endregion
+//#endregion
+export {};

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

@@ -17,6 +17,25 @@ function rootRouteBoundaryPath(route, boundaryPaths, fallbackPath) {
 	if (route.pattern === "/") return fallbackPath ?? null;
 	return boundaryPaths?.[0] ?? fallbackPath ?? null;
 }
+/**
+* The root not-found, forbidden and unauthorized boundaries, which a route
+* without its own boundary falls back to.
+*/
+function rootBoundaryFiles(routes) {
+	const rootRoute = findRootBoundaryRoute(routes);
+	return [
+		rootRouteBoundaryPath(rootRoute, rootRoute?.notFoundPaths, rootRoute?.notFoundPath),
+		rootRouteBoundaryPath(rootRoute, rootRoute?.forbiddenPaths, rootRoute?.forbiddenPath),
+		rootRouteBoundaryPath(rootRoute, rootRoute?.unauthorizedPaths, rootRoute?.unauthorizedPath)
+	].filter((file) => file !== null);
+}
+/**
+* The files a render without a matched route shows (a route-miss 404, or a
+* forbidden or unauthorized boundary): the root layouts and root boundaries.
+*/
+function rootBoundaryRouteFiles(routes) {
+	return [...rootRouteLayoutPaths(findRootBoundaryRoute(routes)), ...rootBoundaryFiles(routes)];
+}
 function createImportAllocator(deferEagerImports) {
 	const imports = [];
 	const importInitializers = [];
@@ -76,6 +95,11 @@ function registerRouteModules(routes, imports) {
 		if (route.unauthorizedPaths) {
 			for (const up of route.unauthorizedPaths) if (up) imports.getLazyLoaderVar(up);
 		}
+		for (const boundaryPath of [
+			...route.segmentNotFoundPaths ?? [],
+			...route.segmentForbiddenPaths ?? [],
+			...route.segmentUnauthorizedPaths ?? []
+		]) imports.getLazyLoaderVar(boundaryPath);
 		for (const slot of route.parallelSlots) {
 			if (slot.pagePath) imports.getLazyLoaderVar(slot.pagePath);
 			if (slot.defaultPath) imports.getLazyLoaderVar(slot.defaultPath);
@@ -85,9 +109,14 @@ function registerRouteModules(routes, imports) {
 			for (const loadingPath of slot.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 			if (slot.errorPath) imports.getLazyLoaderVar(slot.errorPath);
 			if (slot.notFoundPath) imports.getLazyLoaderVar(slot.notFoundPath);
+			for (const notFoundPath of slot.notFoundPaths ?? []) imports.getLazyLoaderVar(notFoundPath);
 			for (const ir of slot.interceptingRoutes) {
 				imports.getLazyLoaderVar(ir.pagePath);
 				if (ir.notFoundPath) imports.getLazyLoaderVar(ir.notFoundPath);
+				for (const forbiddenPath of ir.forbiddenPaths ?? []) imports.getLazyLoaderVar(forbiddenPath);
+				for (const unauthorizedPath of ir.unauthorizedPaths ?? []) imports.getLazyLoaderVar(unauthorizedPath);
+				for (const errorPath of ir.errorPaths ?? []) imports.getLazyLoaderVar(errorPath);
+				for (const notFoundPath of ir.notFoundPaths ?? []) imports.getLazyLoaderVar(notFoundPath);
 				for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
 				for (const loadingPath of ir.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 			}
@@ -95,6 +124,10 @@ function registerRouteModules(routes, imports) {
 		for (const ir of route.siblingIntercepts ?? []) {
 			imports.getLazyLoaderVar(ir.pagePath);
 			if (ir.notFoundPath) imports.getLazyLoaderVar(ir.notFoundPath);
+			for (const forbiddenPath of ir.forbiddenPaths ?? []) imports.getLazyLoaderVar(forbiddenPath);
+			for (const unauthorizedPath of ir.unauthorizedPaths ?? []) imports.getLazyLoaderVar(unauthorizedPath);
+			for (const errorPath of ir.errorPaths ?? []) imports.getLazyLoaderVar(errorPath);
+			for (const notFoundPath of ir.notFoundPaths ?? []) imports.getLazyLoaderVar(notFoundPath);
 			for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
 			for (const loadingPath of ir.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 		}
@@ -134,11 +167,23 @@ function buildRouteEntries(routes, imports) {
       __loadInterceptLoadings: ${lazyLoaderArray(ir.loadingPaths ?? [], imports)},
       interceptLoadingTreePositions: ${JSON.stringify(ir.loadingTreePositions ?? [])},
       interceptNotFoundBranchSegments: ${JSON.stringify(ir.notFoundBranchSegments ?? ir.branchSegments ?? [])},
+      interceptNotFounds: ${moduleArray(ir.notFoundPaths?.length ?? 0)},
+      __loadInterceptNotFounds: ${lazyLoaderArray(ir.notFoundPaths ?? [], imports)},
+      interceptNotFoundTreePositions: ${JSON.stringify(ir.notFoundTreePositions ?? [])},
       page: null,
       __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
       notFound: null,
       __loadNotFound: ${ir.notFoundPath ? imports.getLazyLoaderVar(ir.notFoundPath) : "null"},
       notFoundTreePosition: ${ir.notFoundTreePosition ?? "null"},
+      interceptForbiddens: ${moduleArray(ir.forbiddenPaths?.length ?? 0)},
+      __loadInterceptForbiddens: ${lazyLoaderArray(ir.forbiddenPaths ?? [], imports)},
+      interceptForbiddenTreePositions: ${JSON.stringify(ir.forbiddenTreePositions ?? [])},
+      interceptUnauthorizeds: ${moduleArray(ir.unauthorizedPaths?.length ?? 0)},
+      __loadInterceptUnauthorizeds: ${lazyLoaderArray(ir.unauthorizedPaths ?? [], imports)},
+      interceptUnauthorizedTreePositions: ${JSON.stringify(ir.unauthorizedTreePositions ?? [])},
+      interceptErrors: ${moduleArray(ir.errorPaths?.length ?? 0)},
+      __loadInterceptErrors: ${lazyLoaderArray(ir.errorPaths ?? [], imports)},
+      interceptErrorTreePositions: ${JSON.stringify(ir.errorTreePositions ?? [])},
       params: ${JSON.stringify(ir.params)},
     }`);
 		const slotEntries = route.parallelSlots.map((slot) => {
@@ -155,11 +200,23 @@ function buildRouteEntries(routes, imports) {
           __loadInterceptLoadings: ${lazyLoaderArray(ir.loadingPaths ?? [], imports)},
           interceptLoadingTreePositions: ${JSON.stringify(ir.loadingTreePositions ?? [])},
           interceptNotFoundBranchSegments: ${JSON.stringify(ir.notFoundBranchSegments ?? ir.branchSegments ?? [])},
+          interceptNotFounds: ${moduleArray(ir.notFoundPaths?.length ?? 0)},
+          __loadInterceptNotFounds: ${lazyLoaderArray(ir.notFoundPaths ?? [], imports)},
+          interceptNotFoundTreePositions: ${JSON.stringify(ir.notFoundTreePositions ?? [])},
           page: null,
           __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
           notFound: null,
           __loadNotFound: ${ir.notFoundPath ? imports.getLazyLoaderVar(ir.notFoundPath) : "null"},
           notFoundTreePosition: ${ir.notFoundTreePosition ?? "null"},
+          interceptForbiddens: ${moduleArray(ir.forbiddenPaths?.length ?? 0)},
+          __loadInterceptForbiddens: ${lazyLoaderArray(ir.forbiddenPaths ?? [], imports)},
+          interceptForbiddenTreePositions: ${JSON.stringify(ir.forbiddenTreePositions ?? [])},
+          interceptUnauthorizeds: ${moduleArray(ir.unauthorizedPaths?.length ?? 0)},
+          __loadInterceptUnauthorizeds: ${lazyLoaderArray(ir.unauthorizedPaths ?? [], imports)},
+          interceptUnauthorizedTreePositions: ${JSON.stringify(ir.unauthorizedTreePositions ?? [])},
+          interceptErrors: ${moduleArray(ir.errorPaths?.length ?? 0)},
+          __loadInterceptErrors: ${lazyLoaderArray(ir.errorPaths ?? [], imports)},
+          interceptErrorTreePositions: ${JSON.stringify(ir.errorTreePositions ?? [])},
           params: ${JSON.stringify(ir.params)},
         }`);
 			return `      ${JSON.stringify(slot.key)}: {
@@ -185,6 +242,9 @@ function buildRouteEntries(routes, imports) {
         notFound: null,
         __loadNotFound: ${slot.notFoundPath ? imports.getLazyLoaderVar(slot.notFoundPath) : "null"},
         notFoundTreePosition: ${slot.notFoundTreePosition ?? "null"},
+        notFounds: ${moduleArray(slot.notFoundPaths?.length ?? 0)},
+        __loadNotFounds: ${lazyLoaderArray(slot.notFoundPaths ?? [], imports)},
+        notFoundTreePositions: ${JSON.stringify(slot.notFoundTreePositions ?? [])},
         layoutIndex: ${slot.layoutIndex},
         routeSegments: ${JSON.stringify(slot.routeSegments)},
         slotPatternParts: ${slot.slotPatternParts ? JSON.stringify(slot.slotPatternParts) : "null"},
@@ -195,6 +255,9 @@ ${interceptEntries.join(",\n")}
       }`;
 		});
 		const layoutErrorPaths = route.layoutErrorPaths ?? [];
+		const segmentNotFoundPaths = route.segmentNotFoundPaths ?? [];
+		const segmentForbiddenPaths = route.segmentForbiddenPaths ?? [];
+		const segmentUnauthorizedPaths = route.segmentUnauthorizedPaths ?? [];
 		const errorPaths = route.errorPaths ?? [];
 		const layoutErrorLoaders = lazyLoaderArray(layoutErrorPaths, imports);
 		const errorLoaders = lazyLoaderArray(errorPaths, imports);
@@ -257,6 +320,15 @@ ${siblingInterceptEntries.join(",\n")}
     unauthorizedTreePosition: ${route.unauthorizedTreePosition ?? "null"},
     unauthorizeds: ${moduleArray(unauthorizedPaths.length)},
     __loadUnauthorizeds: ${unauthorizedLoaders},
+    segmentNotFounds: ${moduleArray(segmentNotFoundPaths.length)},
+    __loadSegmentNotFounds: ${lazyLoaderArray(segmentNotFoundPaths, imports)},
+    segmentNotFoundTreePositions: ${JSON.stringify(route.segmentNotFoundTreePositions ?? [])},
+    segmentForbiddens: ${moduleArray(segmentForbiddenPaths.length)},
+    __loadSegmentForbiddens: ${lazyLoaderArray(segmentForbiddenPaths, imports)},
+    segmentForbiddenTreePositions: ${JSON.stringify(route.segmentForbiddenTreePositions ?? [])},
+    segmentUnauthorizeds: ${moduleArray(segmentUnauthorizedPaths.length)},
+    __loadSegmentUnauthorizeds: ${lazyLoaderArray(segmentUnauthorizedPaths, imports)},
+    segmentUnauthorizedTreePositions: ${JSON.stringify(route.segmentUnauthorizedTreePositions ?? [])},
   }`;
 	});
 }
@@ -357,4 +429,4 @@ function buildAppRscManifestCode(options) {
 	};
 }
 //#endregion
-export { buildAppRscManifestCode };
+export { buildAppRscManifestCode, rootBoundaryFiles, rootBoundaryRouteFiles };

package/dist/entries/app-ssr-entry.d.ts

@@ -9,6 +9,9 @@
  * entry also re-exports selected Pages server entry hooks from
  * `virtual:vinext-server-entry` so the RSC bundle can access Pages Router
  * route metadata and fallback dispatchers via `import("./ssr/index.js")`.
+ *
+ * `nitroPublicFilesEntry` wraps the default export for Nitro, so a public file
+ * the router resolves is served by Nitro's static handler.
  */
-export declare function generateSsrEntry(hasPagesDir?: boolean): string;
+export declare function generateSsrEntry(hasPagesDir?: boolean, nitroPublicFilesEntry?: string | null): string;
 //#endregion

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

@@ -10,12 +10,19 @@ import { resolveRuntimeEntryModule } from "./runtime-entry-module.js";
 * entry also re-exports selected Pages server entry hooks from
 * `virtual:vinext-server-entry` so the RSC bundle can access Pages Router
 * route metadata and fallback dispatchers via `import("./ssr/index.js")`.
+*
+* `nitroPublicFilesEntry` wraps the default export for Nitro, so a public file
+* the router resolves is served by Nitro's static handler.
 */
-function generateSsrEntry(hasPagesDir = false) {
+function generateSsrEntry(hasPagesDir = false, nitroPublicFilesEntry = null) {
 	const entryPath = resolveRuntimeEntryModule("app-ssr-entry");
 	return `
 export * from ${JSON.stringify(entryPath)};
-export { default } from ${JSON.stringify(entryPath)};
+${nitroPublicFilesEntry ? `
+import ssrEntry from ${JSON.stringify(entryPath)};
+import { withNitroPublicFiles } from ${JSON.stringify(nitroPublicFilesEntry)};
+export default withNitroPublicFiles(ssrEntry);
+` : `export { default } from ${JSON.stringify(entryPath)};`}
 ${hasPagesDir ? `
 export {
   __ensureInstrumentation,

package/dist/entries/pages-client-entry.d.ts

@@ -6,6 +6,7 @@ import { VinextLinkPrefetchRoute } from "../client/vinext-next-data.js";
 export declare function compileClientMiddlewareMatchers(matcher: StaticMiddlewareMatcher | undefined): unknown[] | undefined;
 export declare function generateClientEntry(pagesDir: string, nextConfig: ResolvedNextConfig, fileMatcher: ReturnType<typeof createValidFileMatcher>, options?: {
   appPrefetchRoutes?: readonly VinextLinkPrefetchRoute[];
+  appRouteHandlers?: readonly VinextLinkPrefetchRoute[];
   instrumentationClientPath?: string | null;
   middlewareMatcher?: StaticMiddlewareMatcher | undefined;
   reactPreamble?: boolean;