vinext 0.1.1 → 0.1.3

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;
 	}
@@ -166,8 +172,5 @@ function createAppPageRscErrorTracker(baseOnError) {
 		}
 	};
 }
-function shouldRerenderAppPageWithGlobalError(options) {
-	return Boolean(options.capturedError) && !options.hasLocalBoundary;
-}
 //#endregion
-export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
+export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

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

@@ -3,8 +3,22 @@ import { AppMiddlewareContext } from "./app-middleware.js";
 //#region src/server/app-pages-bridge.d.ts
 type PagesEntry = {
   handleApiRoute?: (request: Request, url: string) => 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) => Promise<Response> | Response;
 };
+type PagesRouteMatch = {
+  route: {
+    isDynamic: boolean;
+    pattern: string;
+  };
+};
+type AppRouteMatch = {
+  route: {
+    isDynamic: boolean;
+    pattern: string;
+  };
+};
 type RenderPagesFallbackDependencies = {
   loadPagesEntry: () => Promise<PagesEntry> | PagesEntry;
   buildRequestHeaders: (requestHeaders: Headers, middlewareRequestHeaders: Headers) => Headers | null;
@@ -28,8 +42,12 @@ type RenderPagesFallbackDependencies = {
   getDraftModeCookieHeader: () => string | null | undefined;
 };
 type RenderPagesFallbackOptions = {
+  allowRscDocumentFallback?: boolean;
+  appRouteMatch?: AppRouteMatch | null;
   isRscRequest: boolean;
+  matchKind?: "dynamic" | "static";
   middlewareContext: AppMiddlewareContext;
+  pathname?: string;
   request: Request;
   url: URL;
 };

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

@@ -1,11 +1,12 @@
+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, isRscRequest, matchKind, middlewareContext, pathname = options.url.pathname, 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;
@@ -20,17 +21,33 @@ async function renderPagesFallback(options, dependencies) {
 		}
 		pagesRequest = new Request(request.url, pagesRequestInit);
 	}
-	const pagesUrl = decodePathParams(url.pathname) + (url.search || "");
-	const pagesPathname = url.pathname;
+	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 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 pagesRes = await pagesEntry.renderPage(pagesRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
-	if (pagesRes.status === 404) return null;
+	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-route-handler-response.js

@@ -1,7 +1,8 @@
 import "./headers.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { NEVER_CACHE_CONTROL, STATIC_CACHE_CONTROL, applyCdnResponseHeaders, buildCachedRevalidateCacheControl } from "./cache-control.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
+import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-route-handler-response.ts
@@ -11,11 +12,6 @@ function hasMiddlewareHeader(headers) {
 	for (const key of headers.keys()) if (key.startsWith("x-middleware-")) return true;
 	return false;
 }
-function buildRouteHandlerCacheControl(cacheState, revalidateSeconds, expireSeconds) {
-	if (revalidateSeconds === 0) return NEVER_CACHE_CONTROL;
-	if (revalidateSeconds === Infinity) return STATIC_CACHE_CONTROL;
-	return buildCachedRevalidateCacheControl(cacheState, revalidateSeconds, expireSeconds);
-}
 function applyRouteHandlerMiddlewareContext(response, middlewareContext) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const responseHeaders = new Headers(response.headers);
@@ -35,9 +31,14 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 	for (const [key, value] of Object.entries(cachedValue.headers)) if (Array.isArray(value)) for (const entry of value) headers.append(key, entry);
 	else headers.set(key, value);
 	setCacheStateHeaders(headers, options.cacheState);
-	const revalidateSeconds = options.cacheControl?.revalidate ?? options.revalidateSeconds;
-	const expireSeconds = options.cacheControl === void 0 ? void 0 : options.cacheControl.expire ?? options.expireSeconds;
-	applyCdnResponseHeaders(headers, { cacheControl: buildRouteHandlerCacheControl(options.cacheState, revalidateSeconds, expireSeconds) });
+	const { cacheControl } = decideIsr({
+		cacheState: options.cacheState,
+		kind: "app-route",
+		revalidateSeconds: options.revalidateSeconds,
+		expireSeconds: options.expireSeconds,
+		cacheControlMeta: options.cacheControl
+	});
+	applyCdnResponseHeaders(headers, { cacheControl });
 	return new Response(options.isHead ? null : cachedValue.body, {
 		status: cachedValue.status,
 		headers
@@ -45,7 +46,7 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 }
 function applyRouteHandlerRevalidateHeader(response, revalidateSeconds, expireSeconds, tags) {
 	applyCdnResponseHeaders(response.headers, {
-		cacheControl: buildRouteHandlerCacheControl("HIT", revalidateSeconds, expireSeconds),
+		cacheControl: buildAppRouteMissIsrCacheControl(revalidateSeconds, expireSeconds),
 		tags
 	});
 }

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

@@ -1,3 +1,4 @@
+import { addBasePathToPathname } from "../utils/base-path.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "./middleware-request-headers.js";
 import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
 //#region src/server/app-route-handler-runtime.ts
@@ -156,7 +157,17 @@ function createTrackedAppRouteRequest(request, options = {}) {
 			}
 		} });
 	};
-	const wrapRequest = (input) => {
+	const wrapRequest = (rawInput) => {
+		let input = rawInput;
+		if (options.basePath) {
+			const inputUrl = new URL(rawInput.url);
+			const prefixedPathname = addBasePathToPathname(inputUrl.pathname, options.basePath);
+			if (prefixedPathname !== inputUrl.pathname) {
+				inputUrl.pathname = prefixedPathname;
+				const bodySource = rawInput.body && !rawInput.bodyUsed ? rawInput.clone() : rawInput;
+				input = new Request(inputUrl, bodySource);
+			}
+		}
 		const requestHeaders = options.middlewareHeaders ? buildRequestHeadersFromMiddlewareResponse(input.headers, options.middlewareHeaders) : null;
 		const requestWithOverrides = requestHeaders ? rebuildRequestWithHeaders(input, requestHeaders) : input;
 		const nextRequest = requestWithOverrides instanceof NextRequest ? requestWithOverrides : new NextRequest(requestWithOverrides, { nextConfig: nextConfig ?? void 0 });

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);

package/dist/server/app-rsc-handler.d.ts

@@ -1,4 +1,5 @@
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
+import { ImageConfig } from "./image-optimization.js";
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { RootParams } from "../shims/root-params.js";
 import { MiddlewareModule } from "./middleware-runtime.js";
@@ -17,6 +18,7 @@ type RootParamNamesMap = Parameters<typeof handleAppPrerenderEndpoint>[1]["rootP
 type AppRscMiddlewareContext = AppMiddlewareContext;
 type AppRscHandlerRoute = {
   isDynamic: boolean;
+  params?: readonly string[];
   page?: unknown;
   pattern: string;
   rootParamNames?: readonly string[];
@@ -41,6 +43,17 @@ type DispatchMatchedPageOptions<TRoute> = {
   middlewareContext: AppRscMiddlewareContext;
   mountedSlotsHeader: string | null;
   params: AppPageParams;
+  pprFallbackCacheShells?: readonly {
+    fallbackParamNames: readonly string[];
+    params: AppPageParams;
+    pathname: string;
+  }[] | null;
+  pprFallbackShell?: {
+    fallbackParamNames: readonly string[];
+    routePattern: string;
+  };
+  renderedConcreteUrlPaths?: ReadonlySet<string>;
+  skipStaticParamsValidation?: boolean;
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
   request: Request;
@@ -110,8 +123,17 @@ type RenderNotFoundOptions<TRoute> = {
   scriptNonce?: string;
 };
 type RenderPagesFallbackOptions = {
+  allowRscDocumentFallback?: boolean;
+  appRouteMatch?: {
+    route: {
+      isDynamic: boolean;
+      pattern: string;
+    };
+  } | null;
   isRscRequest: boolean;
+  matchKind?: "dynamic" | "static";
   middlewareContext: AppRscMiddlewareContext;
+  pathname?: string;
   request: Request;
   url: URL;
 };
@@ -122,6 +144,7 @@ type NavigationContextValue = {
 };
 type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   basePath: string;
+  cacheComponents?: boolean;
   clearRequestContext: () => void;
   configHeaders: NextHeader[];
   configRedirects: NextRedirect[];
@@ -150,6 +173,8 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   handleProgressiveActionRequest: (options: HandleProgressiveActionRequestOptions) => Promise<Response | ProgressiveActionFormStateResult | null>;
   handleServerActionRequest: (options: HandleServerActionRequestOptions) => Promise<Response | null>;
   i18nConfig: NextI18nConfig | null;
+  imageConfig?: ImageConfig;
+  isDev: boolean;
   isMiddlewareProxy: boolean;
   loadPrerenderPagesRoutes?: () => Promise<unknown>;
   makeThenableParams: MakeThenableParams;