vinext 0.1.2 → 0.1.4

package/dist/server/app-page-render.js

@@ -1,4 +1,4 @@
-import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
+import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
 import { createArtifactCompatibilityEnvelope, createArtifactCompatibilityGraphVersion } from "./artifact-compatibility.js";
 import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import "./app-elements.js";
@@ -249,6 +249,7 @@ function wrapRscResponseForDevErrorReporting(response, consumeInvalidDynamicUsag
 async function renderAppPageLifecycle(options) {
 	const preRenderResult = await probeAppPageBeforeRender({
 		hasLoadingBoundary: options.hasLoadingBoundary,
+		skipProbes: options.pprFallbackShellSignal !== void 0,
 		layoutCount: options.layoutCount,
 		probeLayoutAt(layoutIndex) {
 			return options.probeLayoutAt(layoutIndex);
@@ -315,11 +316,31 @@ async function renderAppPageLifecycle(options) {
 	});
 	const compileEnd = options.isProduction ? void 0 : performance.now();
 	const rscErrorTracker = createAppPageRscErrorTracker(options.createRscOnErrorHandler(options.cleanPathname, options.routePattern));
-	const rscStream = runWithFetchDedupe(() => options.renderToReadableStream(outgoingElement, { onError: rscErrorTracker.onRenderError }));
+	let rscStream = await runWithFetchDedupe(async () => {
+		if (options.pprFallbackShellSignal && options.prerenderToReadableStream) {
+			const reactSignal = options.pprFallbackShellReactSignal ?? options.pprFallbackShellSignal;
+			const pendingResult = options.prerenderToReadableStream(outgoingElement, {
+				onError: rscErrorTracker.onRenderError,
+				signal: reactSignal
+			});
+			if (options.abortPprFallbackShell) setTimeout(options.abortPprFallbackShell, 0);
+			return (await pendingResult).prelude;
+		}
+		return options.renderToReadableStream(outgoingElement, { onError: rscErrorTracker.onRenderError });
+	});
+	let pprFallbackShellRsc = null;
+	if (options.pprFallbackShellSignal) pprFallbackShellRsc = new Uint8Array(await readAppPageBinaryStream(rscStream));
 	let revalidateSeconds = options.revalidateSeconds;
 	let expireSeconds = options.expireSeconds;
 	const shouldCaptureRscForCacheMetadata = options.isProgressiveActionRender !== true && (options.isProduction || options.isPrerender === true) && (revalidateSeconds === null || revalidateSeconds > 0 && revalidateSeconds !== Infinity) && !options.isDraftMode && !options.isForceDynamic && !shouldBypassRscCacheForSkipTransport;
-	const rscCapture = teeAppPageRscStreamForCapture(rscStream, shouldCaptureRscForCacheMetadata);
+	const createBufferedRscStream = (close) => new ReadableStream({ start(controller) {
+		if (pprFallbackShellRsc) controller.enqueue(pprFallbackShellRsc);
+		if (close) controller.close();
+	} });
+	const rscCapture = pprFallbackShellRsc ? {
+		ssrStream: createBufferedRscStream(false),
+		...shouldCaptureRscForCacheMetadata ? { sideStream: createBufferedRscStream(true) } : {}
+	} : teeAppPageRscStreamForCapture(rscStream, shouldCaptureRscForCacheMetadata);
 	const rscForResponse = rscCapture.ssrStream;
 	const capturedRscDataRef = { value: null };
 	if (rscCapture.sideStream && options.isRscRequest) capturedRscDataRef.value = readAppPageBinaryStream(rscCapture.sideStream);
@@ -415,17 +436,19 @@ async function renderAppPageLifecycle(options) {
 			return renderAppPageHtmlStream({
 				capturedRscDataRef,
 				fontData,
+				hasCustomGlobalError: options.hasCustomGlobalError,
 				navigationContext: options.getNavigationContext(),
 				basePath: options.basePath,
 				clientTraceMetadata: options.clientTraceMetadata,
 				reactMaxHeadersLength: options.reactMaxHeadersLength,
 				rootParams: options.rootParams,
+				pprFallbackShellSignal: options.pprFallbackShellSignal,
 				formState: options.formState ?? null,
 				rscStream: rscForResponse,
 				scriptNonce: options.scriptNonce,
 				sideStream: rscCapture.sideStream,
 				ssrHandler,
-				waitForAllReady: options.isPrerender
+				waitForAllReady: options.isPrerender === true
 			});
 		},
 		renderSpecialErrorResponse(specialError) {
@@ -482,6 +505,21 @@ async function renderAppPageLifecycle(options) {
 		renderEnd,
 		responseKind: "html"
 	});
+	if (htmlRender.shellErrorRecovered) {
+		const response = buildAppPageHtmlResponse(safeHtmlStream, {
+			draftCookie,
+			linkHeader,
+			isEdgeRuntime: options.isEdgeRuntime,
+			middlewareContext: {
+				headers: options.middlewareContext.headers,
+				status: 500
+			},
+			policy: { cacheControl: NEVER_CACHE_CONTROL },
+			timing: htmlResponseTiming
+		});
+		applyCdnResponseHeaders(response.headers, { cacheControl: NEVER_CACHE_CONTROL });
+		return response;
+	}
 	const shouldSpeculativelyWriteCache = options.isProduction && shouldCaptureRscForCacheMetadata && revalidateSeconds === null && !options.isDynamicError && !options.isForceStatic && !options.scriptNonce && options.isProgressiveActionRender !== true && !dynamicUsedDuringRender;
 	if (htmlResponsePolicy.shouldWriteToCache || shouldSpeculativelyWriteCache) {
 		const isrResponse = buildAppPageHtmlResponse(safeHtmlStream, {

package/dist/server/app-page-request.d.ts

@@ -29,6 +29,7 @@ type ResolveAppPageGenerateStaticParamsSourcesOptions = {
 };
 type BuildAppPageElementOptions<TElement> = {
   buildPageElement: () => Promise<TElement>;
+  probePageSpecialError?: () => Promise<AppPageSpecialError | null>;
   renderErrorBoundaryPage: (error: unknown) => Promise<Response | null>;
   renderSpecialError: (specialError: AppPageSpecialError) => Promise<Response>;
   resolveSpecialError: (error: unknown) => AppPageSpecialError | null;
@@ -44,6 +45,7 @@ type AppPageInterceptMatch<TPage = unknown> = {
   slotId?: string | null;
   slotKey: string;
   sourceRouteIndex: number;
+  sourcePageSegments?: readonly string[] | null;
 };
 type ResolveAppPageInterceptMatchOptions<TRoute, TPage, TInterceptOpts> = {
   cleanPathname: string;

package/dist/server/app-page-request.js

@@ -180,7 +180,8 @@ async function buildAppPageElement(options) {
 			response: null
 		};
 	} catch (error) {
-		const specialError = options.resolveSpecialError(error);
+		const buildSpecialError = options.resolveSpecialError(error);
+		const specialError = (buildSpecialError ? await options.probePageSpecialError?.() : null) ?? buildSpecialError;
 		if (specialError) return {
 			element: null,
 			response: await options.renderSpecialError(specialError)

package/dist/server/app-page-route-wiring.d.ts

@@ -130,6 +130,7 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
   renderIdentity?: AppPageRenderIdentity;
   renderMode?: AppRscRenderMode;
   routePath: string;
+  sourcePageSegments?: readonly string[] | null;
 };
 declare function createAppPageTreePath(routeSegments: readonly string[] | null | undefined, treePosition: number): string;
 declare function probeAppPageLayoutWithTracking<TModule extends AppPageModule>(options: {
@@ -143,7 +144,8 @@ declare function createAppPageLayoutEntries<TModule extends AppPageModule, TErro
   forbiddens?: readonly (TModule | null | undefined)[] | null;
   unauthorizeds?: readonly (TModule | null | undefined)[] | null;
 }): AppPageLayoutEntry<TModule, TErrorModule>[];
+declare function createAppPageSourcePage(routeSegments: readonly string[] | null | undefined): string;
 declare function createAppPageRouteBodyMetadata(metadata: Metadata | null, pathname: string, metadataPlacement: "body" | "head", trailingSlash?: boolean): ReactNode;
 declare function buildAppPageElements<TModule extends AppPageModule, TErrorModule extends AppPageErrorModule>(options: BuildAppPageElementsOptions<TModule, TErrorModule>): AppElements;
 //#endregion
-export { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute, AppPageSlotOverride, buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };
+export { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute, AppPageSlotOverride, buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };

package/dist/server/app-page-route-wiring.js

@@ -2,7 +2,8 @@ import { createAppRenderDependency, registerAppElementRenderDependencies, render
 import { APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
 import { APP_PREFETCH_LOADING_SHELL_MARKER_KEY } from "./app-elements.js";
-import { ErrorBoundary, ForbiddenBoundary, NotFoundBoundary, RedirectBoundary, UnauthorizedBoundary } from "../shims/error-boundary.js";
+import DefaultGlobalError from "../shims/default-global-error.js";
+import { ErrorBoundary, ForbiddenBoundary, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, UnauthorizedBoundary } from "../shims/error-boundary.js";
 import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead, renderMetadataToHtml } from "../shims/metadata.js";
@@ -14,6 +15,7 @@ import { Fragment, Suspense } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/server/app-page-route-wiring.tsx
 const APP_PAGE_LAYOUT_PROBE_CHILD = /* @__PURE__ */ jsx(Fragment, {});
+const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
 function getDefaultExport(module) {
 	return module?.default ?? null;
 }
@@ -85,6 +87,9 @@ function createAppPageTemplateEntries(route) {
 		};
 	});
 }
+function createAppPageSourcePage(routeSegments) {
+	return `/${[...routeSegments ?? [], "page"].join("/")}`;
+}
 function createAppPageErrorEntries(route) {
 	return (route.errorPaths ?? route.errors ?? []).flatMap((errorModule, index) => {
 		if (!errorModule) return [];
@@ -206,6 +211,7 @@ function buildAppPageElements(options) {
 		layoutIds: options.route.ids?.layouts ?? layoutEntries.map((entry) => entry.id),
 		rootLayoutTreePath,
 		routeId,
+		sourcePage: createAppPageSourcePage(options.sourcePageSegments ?? routeSegments),
 		slotBindings: createAppPageSlotBindings(options.route, layoutEntries, resolveSlotOverride, {
 			interception: renderIdentity?.interception ?? options.interception ?? null,
 			interceptionContext,
@@ -427,9 +433,12 @@ function buildAppPageElements(options) {
 		});
 	}
 	const globalErrorComponent = getErrorBoundaryExport(options.globalErrorModule);
-	if (globalErrorComponent) routeChildren = /* @__PURE__ */ jsx(ErrorBoundary, {
-		fallback: globalErrorComponent,
-		children: routeChildren
+	routeChildren = /* @__PURE__ */ jsx(GlobalErrorBoundary, {
+		fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+		children: globalErrorComponent ? /* @__PURE__ */ jsx(ErrorBoundary, {
+			fallback: globalErrorComponent,
+			children: routeChildren
+		}) : routeChildren
 	});
 	elements[routeId] = /* @__PURE__ */ jsxs(Fragment$1, { children: [
 		createAppPageRouteHead(options.resolvedMetadata, options.resolvedViewport, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement, options.trailingSlash),
@@ -440,4 +449,4 @@ function buildAppPageElements(options) {
 	return elements;
 }
 //#endregion
-export { buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };
+export { buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };

package/dist/server/app-page-stream.d.ts

@@ -18,6 +18,7 @@ type AppSsrRenderResult = {
   htmlStream: ReadableStream<Uint8Array>;
   metadataReady: Promise<void>;
   capturedRscData: Promise<ArrayBuffer> | null;
+  shellErrorRecovered?: boolean;
   /**
    * Preload `Link` header value emitted by React during SSR (via `onHeaders`),
    * already capped to `reactMaxHeadersLength`. Empty/undefined when React
@@ -62,9 +63,14 @@ type AppPageSsrHandler = {
     sideStream?: ReadableStream<Uint8Array>;
     capturedRscDataRef?: {
       value: Promise<ArrayBuffer> | null;
-    }; /** When true, wait for the full React tree before emitting bytes. */
+    }; /** Abort signal for a build-time PPR fallback-shell static render. */
+    pprFallbackShellSignal?: AbortSignal; /** When true, wait for the full React tree before emitting bytes. */
     waitForAllReady?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
     initialDevServerError?: unknown;
+    /** When true, an SSR-phase-only shell render error resolves to the
+     *  default `__next_error__` error-document shell (with the original
+     *  flight payload and bootstrap) instead of rejecting. See handleSsr. */
+    fallbackToErrorDocumentOnShellError?: boolean;
   }) => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
 };
 type RenderAppPageHtmlStreamOptions = {
@@ -93,9 +99,14 @@ type RenderAppPageHtmlStreamOptions = {
   sideStream?: ReadableStream<Uint8Array>; /** Out-parameter filled with accumulated raw RSC bytes after stream consumption. */
   capturedRscDataRef?: {
     value: Promise<ArrayBuffer> | null;
-  }; /** When true, wait for the full React tree before emitting bytes. */
+  }; /** Abort signal for a build-time PPR fallback-shell static render. */
+  pprFallbackShellSignal?: AbortSignal; /** When true, wait for the full React tree before emitting bytes. */
   waitForAllReady?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
   initialDevServerError?: unknown;
+  /** True when the app supplies a custom global-error.tsx. Disables the
+   *  default error-document shell fallback so SSR shell errors keep driving
+   *  the server-rendered global-error boundary re-render. */
+  hasCustomGlobalError?: boolean;
 };
 type RenderAppPageHtmlResponseOptions = {
   clearRequestContext: () => void;
@@ -108,7 +119,8 @@ type AppPageHtmlStreamRecoveryResult = {
   htmlStream: ReadableStream<Uint8Array> | null;
   response: Response | null;
   metadataReady: Promise<void>;
-  capturedRscData: Promise<ArrayBuffer> | null; /** React-emitted preload `Link` header (already capped). */
+  capturedRscData: Promise<ArrayBuffer> | null;
+  shellErrorRecovered: boolean; /** React-emitted preload `Link` header (already capped). */
   linkHeader?: string;
 };
 type RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError> = {

package/dist/server/app-page-stream.js

@@ -11,7 +11,8 @@ function normalizeAppSsrRenderResult(raw, fallbackCapturedRscData = null) {
 	return {
 		htmlStream: raw,
 		metadataReady: resolvedMetadataReady,
-		capturedRscData: fallbackCapturedRscData
+		capturedRscData: fallbackCapturedRscData,
+		shellErrorRecovered: false
 	};
 }
 /**
@@ -62,8 +63,10 @@ async function renderAppPageHtmlStream(options) {
 		rootParams: options.rootParams,
 		sideStream: options.sideStream,
 		capturedRscDataRef: options.capturedRscDataRef,
+		pprFallbackShellSignal: options.pprFallbackShellSignal,
 		waitForAllReady: options.waitForAllReady,
-		initialDevServerError: options.initialDevServerError
+		initialDevServerError: options.initialDevServerError,
+		fallbackToErrorDocumentOnShellError: options.waitForAllReady !== true && options.hasCustomGlobalError === false
 	};
 	return normalizeAppSsrRenderResult(await options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions), options.capturedRscDataRef?.value ?? null);
 }
@@ -121,13 +124,14 @@ async function renderAppPageHtmlResponse(options) {
 }
 async function renderAppPageHtmlStreamWithRecovery(options) {
 	try {
-		const { htmlStream, metadataReady, capturedRscData, linkHeader } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
+		const { htmlStream, metadataReady, capturedRscData, linkHeader, shellErrorRecovered } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
 		options.onShellRendered?.();
 		return {
 			htmlStream,
 			response: null,
 			metadataReady,
 			capturedRscData,
+			shellErrorRecovered: shellErrorRecovered === true,
 			linkHeader
 		};
 	} catch (error) {
@@ -136,14 +140,16 @@ async function renderAppPageHtmlStreamWithRecovery(options) {
 			htmlStream: null,
 			response: await options.renderSpecialErrorResponse(specialError),
 			metadataReady: resolvedMetadataReady,
-			capturedRscData: null
+			capturedRscData: null,
+			shellErrorRecovered: false
 		};
 		const boundaryResponse = await options.renderErrorBoundaryResponse(error);
 		if (boundaryResponse) return {
 			htmlStream: null,
 			response: boundaryResponse,
 			metadataReady: resolvedMetadataReady,
-			capturedRscData: null
+			capturedRscData: null,
+			shellErrorRecovered: false
 		};
 		throw error;
 	}

package/dist/server/app-pages-bridge.d.ts

@@ -3,7 +3,23 @@ import { AppMiddlewareContext } from "./app-middleware.js";
 //#region src/server/app-pages-bridge.d.ts
 type PagesEntry = {
   handleApiRoute?: (request: Request, url: string) => Promise<Response> | Response;
-  renderPage?: (request: Request, url: string, query: Record<string, unknown>, parsedUrl: unknown, middlewareRequestHeaders?: Headers | null) => Promise<Response> | Response;
+  matchApiRoute?: (url: string, request: Request) => PagesRouteMatch | null;
+  matchPageRoute?: (url: string, request: Request) => PagesRouteMatch | null;
+  renderPage?: (request: Request, url: string, query: Record<string, unknown>, parsedUrl: unknown, middlewareRequestHeaders?: Headers | null, options?: {
+    isDataReq?: boolean;
+  }) => Promise<Response> | Response;
+};
+type PagesRouteMatch = {
+  route: {
+    isDynamic: boolean;
+    pattern: string;
+  };
+};
+type AppRouteMatch = {
+  route: {
+    isDynamic: boolean;
+    pattern: string;
+  };
 };
 type RenderPagesFallbackDependencies = {
   loadPagesEntry: () => Promise<PagesEntry> | PagesEntry;
@@ -28,8 +44,14 @@ type RenderPagesFallbackDependencies = {
   getDraftModeCookieHeader: () => string | null | undefined;
 };
 type RenderPagesFallbackOptions = {
+  allowRscDocumentFallback?: boolean;
+  appRouteMatch?: AppRouteMatch | null;
+  isDataRequest?: boolean;
   isRscRequest: boolean;
+  matchKind?: "dynamic" | "static";
   middlewareContext: AppMiddlewareContext;
+  pathname?: string;
+  pagesDataRequest?: Request | null;
   request: Request;
   url: URL;
 };

package/dist/server/app-pages-bridge.js

@@ -1,36 +1,45 @@
+import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
+import { pagesRouteHasPriorityOverAppRoute } from "./hybrid-route-priority.js";
 //#region src/server/app-pages-bridge.ts
 /**
 * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
 */
 async function renderPagesFallback(options, dependencies) {
-	const { isRscRequest, middlewareContext, request, url } = options;
+	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, url } = options;
 	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
-	if (isRscRequest) return null;
+	if (isRscRequest && !allowRscDocumentFallback) return null;
 	const pagesEntry = await loadPagesEntry();
 	const pagesRequestHeaders = middlewareContext.requestHeaders ? buildRequestHeaders(request.headers, middlewareContext.requestHeaders) : null;
 	let pagesRequest = request;
-	if (pagesRequestHeaders) {
-		const pagesRequestInit = {
-			method: request.method,
-			headers: pagesRequestHeaders
-		};
-		if (request.method !== "GET" && request.method !== "HEAD") {
-			pagesRequestInit.body = request.body;
-			pagesRequestInit.duplex = "half";
-		}
-		pagesRequest = new Request(request.url, pagesRequestInit);
-	}
-	const pagesUrl = decodePathParams(url.pathname) + (url.search || "");
-	const pagesPathname = url.pathname;
+	if (pagesRequestHeaders) pagesRequest = cloneRequestWithHeaders(request, pagesRequestHeaders);
+	const queryIndex = pathname.indexOf("?");
+	const pagesPathname = queryIndex === -1 ? pathname : pathname.slice(0, queryIndex);
+	const pagesSearch = queryIndex === -1 ? url.search || "" : pathname.slice(queryIndex);
+	const pagesUrl = decodePathParams(pagesPathname) + pagesSearch;
 	if (pagesPathname.startsWith("/api/") || pagesPathname === "/api") {
 		if (typeof pagesEntry.handleApiRoute !== "function") return null;
+		const hasApiMatcher = typeof pagesEntry.matchApiRoute === "function";
+		const apiMatch = hasApiMatcher ? pagesEntry.matchApiRoute?.(pagesUrl, pagesRequest) ?? null : null;
+		if (hasApiMatcher && apiMatch === null) return null;
+		if (apiMatch !== null && matchKind === "static" && apiMatch.route.isDynamic) return null;
+		if (apiMatch !== null && matchKind === "dynamic" && !apiMatch.route.isDynamic) return null;
+		if (appRouteMatch !== null) {
+			if (apiMatch === null || !pagesRouteHasPriorityOverAppRoute(apiMatch.route, appRouteMatch.route)) return null;
+		}
 		const pagesApiResponse = await pagesEntry.handleApiRoute(pagesRequest, pagesUrl);
 		const draftCookie = getDraftModeCookieHeader();
 		return applyDraftModeCookie(applyRouteHandlerMiddlewareContext(pagesApiResponse, middlewareContext), draftCookie);
 	}
 	if (typeof pagesEntry.renderPage !== "function") return null;
-	const pagesRes = await pagesEntry.renderPage(pagesRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
-	if (pagesRes.status === 404) return null;
+	const hasPageMatcher = typeof pagesEntry.matchPageRoute === "function";
+	const pageMatch = hasPageMatcher ? pagesEntry.matchPageRoute?.(pagesUrl, pagesRequest) ?? null : null;
+	if (hasPageMatcher && pageMatch === null) return null;
+	if (pageMatch !== null && matchKind === "static" && pageMatch.route.isDynamic) return null;
+	if (pageMatch !== null && matchKind === "dynamic" && !pageMatch.route.isDynamic) return null;
+	if (appRouteMatch !== null && (pageMatch === null || !pagesRouteHasPriorityOverAppRoute(pageMatch.route, appRouteMatch.route))) return null;
+	const renderRequest = pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest;
+	const pagesRes = isDataRequest ? await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders, { isDataReq: true }) : await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
+	if (pagesRes.status === 404 && pageMatch === null) return null;
 	return applyDraftModeCookie(pagesRes, getDraftModeCookieHeader());
 }
 /**

package/dist/server/app-ppr-fallback-shell-render.d.ts

@@ -0,0 +1,17 @@
+import { PprFallbackShellState } from "../shims/ppr-fallback-shell.js";
+import { ReactNode } from "react";
+
+//#region src/server/app-ppr-fallback-shell-render.d.ts
+type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
+type AppPageRenderableElement = ReactNode | Record<string, ReactNode>;
+declare function warmPprFallbackShellCaches(options: {
+  element: AppPageRenderableElement;
+  onError: AppPageBoundaryOnError;
+  renderToReadableStream: (element: AppPageRenderableElement, options: {
+    onError: AppPageBoundaryOnError;
+    signal?: AbortSignal;
+  }) => ReadableStream<Uint8Array>;
+  state: PprFallbackShellState;
+}): Promise<void>;
+//#endregion
+export { warmPprFallbackShellCaches };

package/dist/server/app-ppr-fallback-shell-render.js

@@ -0,0 +1,26 @@
+import { isPprFallbackShellAbortError, preparePprFallbackShellFinalRender, waitForPprFallbackShellCacheReady } from "../shims/ppr-fallback-shell.js";
+import { readAppPageBinaryStream } from "./app-page-execution.js";
+//#region src/server/app-ppr-fallback-shell-render.ts
+async function warmPprFallbackShellCaches(options) {
+	let warmupError = null;
+	const warmupDrain = readAppPageBinaryStream(options.renderToReadableStream(options.element, {
+		signal: options.state.abortController.signal,
+		onError(error, requestInfo, errorContext) {
+			if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
+			return options.onError(error, requestInfo, errorContext);
+		}
+	})).catch((error) => {
+		if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
+		warmupError = error;
+	});
+	try {
+		await waitForPprFallbackShellCacheReady(options.state);
+	} finally {
+		options.state.abortController.abort();
+		await warmupDrain;
+		preparePprFallbackShellFinalRender(options.state);
+	}
+	if (warmupError) throw warmupError;
+}
+//#endregion
+export { warmPprFallbackShellCaches };

package/dist/server/app-ppr-fallback-shell.d.ts

@@ -9,6 +9,18 @@ type AppPprFallbackShell = {
   pathname: string;
   params: Record<string, string | string[]>;
 };
+/**
+ * A fallback-shell cache entry as consumed by the dispatch layer.
+ * Produced at build time by the PPR prerender and served at request time
+ * when the exact cache entry for a dynamic child param is missing.
+ */
+type AppPagePprFallbackCacheShell = {
+  fallbackParamNames: readonly string[];
+  params: Record<string, string | string[]>;
+  pathname: string;
+};
+declare function markAppPprDynamicFallbackShellHtml(html: string): string;
+declare function isAppPprDynamicFallbackShellHtml(html: string): boolean;
 declare function createAppPprFallbackShell(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell | null;
 declare function createAppPprFallbackShells(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell[];
 declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
@@ -18,4 +30,4 @@ declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
   searchParams: URLSearchParams;
 }): string;
 //#endregion
-export { createAppPprFallbackShell, createAppPprFallbackShells, rewriteAppPprFallbackShellHtmlNavigation };
+export { AppPagePprFallbackCacheShell, createAppPprFallbackShell, createAppPprFallbackShells, isAppPprDynamicFallbackShellHtml, markAppPprDynamicFallbackShellHtml, rewriteAppPprFallbackShellHtmlNavigation };

package/dist/server/app-ppr-fallback-shell.js

@@ -1,6 +1,13 @@
 import { createInlineScriptTag } from "./html.js";
 import { createNavigationRuntimeRscMetadataScript } from "./app-ssr-stream.js";
 //#region src/server/app-ppr-fallback-shell.ts
+const PPR_DYNAMIC_FALLBACK_SHELL_MARKER = "<!--vinext-ppr-dynamic-fallback-shell-->";
+function markAppPprDynamicFallbackShellHtml(html) {
+	return html + PPR_DYNAMIC_FALLBACK_SHELL_MARKER;
+}
+function isAppPprDynamicFallbackShellHtml(html) {
+	return html.includes(PPR_DYNAMIC_FALLBACK_SHELL_MARKER);
+}
 function routeRootParamNames(route) {
 	return new Set(route.rootParamNames ?? []);
 }
@@ -79,4 +86,4 @@ function rewriteAppPprFallbackShellHtmlNavigation(options) {
 	return metadataScript + options.html;
 }
 //#endregion
-export { createAppPprFallbackShell, createAppPprFallbackShells, rewriteAppPprFallbackShellHtmlNavigation };
+export { createAppPprFallbackShell, createAppPprFallbackShells, isAppPprDynamicFallbackShellHtml, markAppPprDynamicFallbackShellHtml, rewriteAppPprFallbackShellHtmlNavigation };

package/dist/server/app-route-handler-dispatch.js

@@ -2,16 +2,17 @@ import { createRequestContext, runWithRequestContext } from "../shims/unified-re
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { consumeDynamicUsage, getAndClearPendingCookies, getDraftModeCookieHeader, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
-import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { setNavigationContext } from "../shims/navigation.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
+import { buildPageCacheTags } from "./implicit-tags.js";
 import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
 import { applyRouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
 import { executeAppRouteHandler } from "./app-route-handler-execution.js";
 import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
+import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 //#region src/server/app-route-handler-dispatch.ts
 function isAppRouteHandlerFunction(value) {
 	return typeof value === "function";
@@ -32,6 +33,8 @@ async function runInRouteHandlerRevalidationContext(options, renderFn) {
 	}), async () => {
 		ensureFetchPatch();
 		setCurrentFetchSoftTags(buildRouteHandlerPageCacheTags(options.cleanPathname, [], options.routeSegments));
+		setCurrentFetchCacheMode(options.fetchCacheMode);
+		setCurrentForceDynamicFetchDefault(options.dynamicConfig === "force-dynamic");
 		await renderFn();
 	});
 }
@@ -56,6 +59,9 @@ async function dispatchAppRouteHandler(options) {
 		}), options.middlewareContext);
 	}
 	const resolvedHandlerFn = isAppRouteHandlerFunction(handlerFn) ? handlerFn : void 0;
+	const fetchCacheMode = resolveAppRouteHandlerFetchCacheMode(handler);
+	setCurrentFetchCacheMode(fetchCacheMode);
+	setCurrentForceDynamicFetchDefault(handler.dynamic === "force-dynamic");
 	if (revalidateSeconds !== null && shouldReadAppRouteHandlerCache({
 		dynamicConfig: handler.dynamic,
 		handlerFn: resolvedHandlerFn,
@@ -96,6 +102,7 @@ async function dispatchAppRouteHandler(options) {
 					cleanPathname: options.cleanPathname,
 					draftModeSecret: options.draftModeSecret,
 					dynamicConfig: handler.dynamic,
+					fetchCacheMode,
 					routePattern: route.pattern,
 					routeSegments: route.routeSegments
 				}, renderFn);

package/dist/server/app-route-handler-policy.d.ts

@@ -3,6 +3,7 @@ import { RouteHandlerHttpMethod, RouteHandlerModule } from "./app-route-handler-
 //#region src/server/app-route-handler-policy.d.ts
 type AppRouteHandlerModule = {
   dynamic?: string;
+  fetchCache?: unknown;
   revalidate?: unknown;
 } & RouteHandlerModule;
 type AppRouteHandlerFunction = (...args: unknown[]) => unknown;

package/dist/server/app-router-entry.js

@@ -1,9 +1,11 @@
 import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { cloneRequestWithHeaders, filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { resolveStaticAssetSignal } from "./worker-utils.js";
+import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import rscHandler, { __assetPrefix, __basePath } from "virtual:vinext-rsc-entry";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 //#region src/server/app-router-entry.ts
@@ -23,7 +25,10 @@ async function handleRequest(request, env, ctx) {
 	}
 	if (isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix)) return notFoundStaticAssetResponse();
 	{
+		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
 		const filteredHeaders = filterInternalHeaders(request.headers);
+		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
+		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
 		request = cloneRequestWithHeaders(request, filteredHeaders);
 	}
 	const handleFn = () => rscHandler(request, ctx);

package/dist/server/app-rsc-cache-busting.js

@@ -1,6 +1,7 @@
 import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { parseAppRscRenderMode } from "./app-rsc-render-mode.js";
+import { applyDeploymentIdHeader } from "../utils/deployment-id.js";
 //#region src/server/app-rsc-cache-busting.ts
 /**
 * RSC cache-busting hashes cover the headers that make an RSC payload vary.
@@ -148,6 +149,7 @@ function createRscRequestHeaders(options = {}) {
 		Accept: VINEXT_RSC_CONTENT_TYPE,
 		["RSC"]: "1"
 	});
+	applyDeploymentIdHeader(headers);
 	if (options.interceptionContext !== void 0 && options.interceptionContext !== null) headers.set(VINEXT_INTERCEPTION_CONTEXT_HEADER, options.interceptionContext);
 	if (options.mountedSlotsHeader !== void 0 && options.mountedSlotsHeader !== null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
 	if (options.clientReuseManifestHeader !== void 0 && options.clientReuseManifestHeader !== null) headers.set(VINEXT_CLIENT_REUSE_MANIFEST_HEADER, options.clientReuseManifestHeader);