vinext 0.2.0 → 0.2.1

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

@@ -27,8 +27,14 @@ function buildResponseTiming(options) {
 	};
 }
 function readRequestCacheLifeForPrerender(options) {
+	if (options.isEdgeRuntime && options.revalidateSeconds === null) return (options.peekRequestCacheLife?.() ?? options.getRequestCacheLife())?.revalidate !== void 0 ? { revalidate: 0 } : null;
 	return options.peekRequestCacheLife?.() ?? options.getRequestCacheLife();
 }
+function readRequestCacheLifeForCachePolicy(options) {
+	const requestCacheLife = options.getRequestCacheLife();
+	if (options.isEdgeRuntime && options.revalidateSeconds === null) return null;
+	return requestCacheLife;
+}
 function applyRequestCacheLife(options) {
 	let revalidateSeconds = options.revalidateSeconds;
 	let expireSeconds = options.expireSeconds;
@@ -40,6 +46,10 @@ function applyRequestCacheLife(options) {
 		revalidateSeconds
 	};
 }
+function resolveAppPageCacheWriteRevalidateSeconds(options) {
+	if (options.revalidateSeconds === null && (options.isForceStatic || options.isDynamicError)) return Infinity;
+	return options.revalidateSeconds;
+}
 function readRootBoundaryId(element) {
 	const rootLayoutTreePath = element[AppElementsWire.keys.rootLayout];
 	return typeof rootLayoutTreePath === "string" ? rootLayoutTreePath : null;
@@ -338,6 +348,8 @@ async function renderAppPageLifecycle(options) {
 	if (options.pprFallbackShellSignal) pprFallbackShellRsc = new Uint8Array(await readAppPageBinaryStream(rscStream));
 	let revalidateSeconds = options.revalidateSeconds;
 	let expireSeconds = options.expireSeconds;
+	const shouldWaitForAllReady = options.isPrerender === true && options.isSpeculativePrerender !== true;
+	const shouldReadRequestCacheLifeForPrerender = options.isPrerender === true;
 	const shouldCaptureRscForCacheMetadata = options.isProgressiveActionRender !== true && (options.isProduction || options.isPrerender === true) && (revalidateSeconds === null || revalidateSeconds > 0 && revalidateSeconds !== Infinity) && !options.isDraftMode && !options.isForceDynamic && !shouldBypassRscCacheForSkipTransport;
 	const createBufferedRscStream = (close) => new ReadableStream({ start(controller) {
 		if (pprFallbackShellRsc) controller.enqueue(pprFallbackShellRsc);
@@ -351,11 +363,13 @@ async function renderAppPageLifecycle(options) {
 	const capturedRscDataRef = { value: null };
 	if (rscCapture.sideStream && options.isRscRequest) capturedRscDataRef.value = readAppPageBinaryStream(rscCapture.sideStream);
 	if (options.isRscRequest) {
-		if (options.isPrerender === true) {
-			await settleCapturedRscRenderForCacheMetadata(capturedRscDataRef.value);
+		let requestCacheLifeForPrerender = null;
+		if (shouldWaitForAllReady) await settleCapturedRscRenderForCacheMetadata(capturedRscDataRef.value);
+		if (shouldReadRequestCacheLifeForPrerender) {
+			requestCacheLifeForPrerender = readRequestCacheLifeForPrerender(options);
 			({expireSeconds, revalidateSeconds} = applyRequestCacheLife({
 				expireSeconds,
-				requestCacheLife: readRequestCacheLifeForPrerender(options),
+				requestCacheLife: requestCacheLifeForPrerender,
 				revalidateSeconds
 			}));
 		}
@@ -378,6 +392,8 @@ async function renderAppPageLifecycle(options) {
 			mountedSlotsHeader: options.mountedSlotsHeader,
 			params: options.navigationParams,
 			policy: rscResponsePolicy,
+			renderedPathAndSearch: options.renderedPathAndSearch,
+			requestCacheLife: requestCacheLifeForPrerender,
 			timing: buildResponseTiming({
 				compileEnd,
 				handlerStart: options.handlerStart,
@@ -407,17 +423,22 @@ async function renderAppPageLifecycle(options) {
 				return options.getPageTags();
 			},
 			getRequestCacheLife() {
-				return options.getRequestCacheLife();
+				return readRequestCacheLifeForCachePolicy(options);
 			},
 			isrDebug: options.isrDebug,
 			isrRscKey: options.isrRscKey,
 			isrSet: options.isrSet,
 			interceptionContext: options.interceptionContext,
 			mountedSlotsHeader: options.mountedSlotsHeader,
+			omitPendingDynamicCacheState: options.omitPendingDynamicCacheState,
 			renderMode: options.renderMode,
 			preserveClientResponseHeaders: rscResponsePolicy.cacheState !== "MISS",
 			expireSeconds,
-			revalidateSeconds,
+			revalidateSeconds: resolveAppPageCacheWriteRevalidateSeconds({
+				isDynamicError: options.isDynamicError,
+				isForceStatic: options.isForceStatic,
+				revalidateSeconds
+			}),
 			waitUntil(promise) {
 				options.waitUntil?.(promise);
 			}
@@ -469,7 +490,8 @@ async function renderAppPageLifecycle(options) {
 				scriptNonce: options.scriptNonce,
 				sideStream: rscCapture.sideStream,
 				ssrHandler,
-				waitForAllReady: options.isPrerender === true
+				fallbackToErrorDocumentOnShellError: options.isPrerender === true && options.isSpeculativePrerender === true ? false : void 0,
+				waitForAllReady: shouldWaitForAllReady
 			});
 		},
 		renderSpecialErrorResponse(specialError) {
@@ -492,15 +514,27 @@ async function renderAppPageLifecycle(options) {
 			}
 		}
 	}
-	if (options.isPrerender === true) {
-		await settleCapturedRscRenderForCacheMetadata(htmlRender.capturedRscData);
+	let requestCacheLifeForPrerender = null;
+	let dynamicUsedDuringRender = options.consumeDynamicUsage();
+	dynamicUsedDuringHtmlRender = dynamicUsedDuringRender;
+	const stopSpeculativeMetadataWaitOnDynamicUsage = options.isSpeculativePrerender === true && shouldReadRequestCacheLifeForPrerender ? () => {
+		if (dynamicUsedDuringRender || (options.peekDynamicUsage?.() ?? peekDynamicUsage())) {
+			dynamicUsedDuringRender = true;
+			dynamicUsedDuringHtmlRender = true;
+			return true;
+		}
+		return false;
+	} : void 0;
+	if (shouldWaitForAllReady || shouldReadRequestCacheLifeForPrerender) await settleCapturedRscRenderForCacheMetadata(htmlRender.capturedRscData, stopSpeculativeMetadataWaitOnDynamicUsage);
+	if (shouldReadRequestCacheLifeForPrerender) {
+		requestCacheLifeForPrerender = readRequestCacheLifeForPrerender(options);
 		({expireSeconds, revalidateSeconds} = applyRequestCacheLife({
 			expireSeconds,
-			requestCacheLife: readRequestCacheLifeForPrerender(options),
+			requestCacheLife: requestCacheLifeForPrerender,
 			revalidateSeconds
 		}));
 	}
-	let dynamicUsedDuringRender = options.consumeDynamicUsage();
+	dynamicUsedDuringRender = dynamicUsedDuringRender || options.consumeDynamicUsage();
 	dynamicUsedDuringHtmlRender = dynamicUsedDuringRender;
 	const draftCookie = options.getDraftModeCookieHeader();
 	let dynamicUsedBeforeContextCleanup = dynamicUsedDuringRender;
@@ -538,12 +572,13 @@ async function renderAppPageLifecycle(options) {
 				status: 500
 			},
 			policy: { cacheControl: NEVER_CACHE_CONTROL },
+			requestCacheLife: requestCacheLifeForPrerender,
 			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;
+	const shouldSpeculativelyWriteCache = options.isProduction && shouldCaptureRscForCacheMetadata && !options.isEdgeRuntime && revalidateSeconds === null && !options.isDynamicError && !options.isForceStatic && !options.scriptNonce && options.isProgressiveActionRender !== true && !dynamicUsedDuringRender;
 	if (htmlResponsePolicy.shouldWriteToCache || shouldSpeculativelyWriteCache) {
 		const isrResponse = buildAppPageHtmlResponse(safeHtmlStream, {
 			draftCookie,
@@ -551,6 +586,7 @@ async function renderAppPageLifecycle(options) {
 			isEdgeRuntime: options.isEdgeRuntime,
 			middlewareContext: options.middlewareContext,
 			policy: htmlResponsePolicy,
+			requestCacheLife: requestCacheLifeForPrerender,
 			timing: htmlResponseTiming
 		});
 		if (options.isPrerender === true) return isrResponse;
@@ -590,7 +626,7 @@ async function renderAppPageLifecycle(options) {
 				return options.getPageTags();
 			},
 			getRequestCacheLife() {
-				return options.getRequestCacheLife();
+				return readRequestCacheLifeForCachePolicy(options);
 			},
 			isrDebug: options.isrDebug,
 			isrHtmlKey: options.isrHtmlKey,
@@ -600,7 +636,11 @@ async function renderAppPageLifecycle(options) {
 			omitPendingDynamicCacheState: options.omitPendingDynamicCacheState,
 			preserveClientResponseHeaders: !htmlResponsePolicy.shouldWriteToCache,
 			expireSeconds,
-			revalidateSeconds,
+			revalidateSeconds: resolveAppPageCacheWriteRevalidateSeconds({
+				isDynamicError: options.isDynamicError,
+				isForceStatic: options.isForceStatic,
+				revalidateSeconds
+			}),
 			waitUntil(cachePromise) {
 				options.waitUntil?.(cachePromise);
 			}
@@ -612,14 +652,25 @@ async function renderAppPageLifecycle(options) {
 		isEdgeRuntime: options.isEdgeRuntime,
 		middlewareContext: options.middlewareContext,
 		policy: htmlResponsePolicy,
+		requestCacheLife: requestCacheLifeForPrerender,
 		timing: htmlResponseTiming
 	});
 }
-async function settleCapturedRscRenderForCacheMetadata(capturedRscDataPromise) {
+async function settleCapturedRscRenderForCacheMetadata(capturedRscDataPromise, shouldStopWaiting) {
 	if (!capturedRscDataPromise) return;
+	if (!shouldStopWaiting) {
+		try {
+			await capturedRscDataPromise;
+		} catch {}
+		return;
+	}
+	let settled = false;
+	const settledPromise = capturedRscDataPromise.catch(() => {}).then(() => {
+		settled = true;
+	});
 	try {
-		await capturedRscDataPromise;
-	} catch {}
+		while (!settled && !shouldStopWaiting()) await Promise.race([settledPromise, new Promise((resolve) => setTimeout(resolve, 0))]);
+	} finally {}
 }
 //#endregion
 export { renderAppPageLifecycle };

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

@@ -15,6 +15,10 @@ type AppPageResponsePolicy = {
   cacheControl?: string;
   cacheState?: "MISS" | "STATIC";
 };
+type AppPagePrerenderCacheLife = {
+  expire?: number;
+  revalidate?: number;
+};
 type ResolveAppPageResponsePolicyBaseOptions = {
   isDraftMode: boolean;
   isDynamicError: boolean;
@@ -42,6 +46,8 @@ type BuildAppPageRscResponseOptions = {
   mountedSlotsHeader?: string | null;
   params?: Record<string, unknown>;
   policy: AppPageResponsePolicy;
+  renderedPathAndSearch?: string | null;
+  requestCacheLife?: AppPagePrerenderCacheLife | null;
   timing?: AppPageResponseTiming;
 };
 type BuildAppPageHtmlResponseOptions = {
@@ -50,6 +56,7 @@ type BuildAppPageHtmlResponseOptions = {
   isEdgeRuntime?: boolean;
   middlewareContext: AppPageMiddlewareContext;
   policy: AppPageResponsePolicy;
+  requestCacheLife?: AppPagePrerenderCacheLife | null;
   timing?: AppPageResponseTiming;
 };
 declare function resolveAppPageRscResponsePolicy(options: ResolveAppPageRscResponsePolicyOptions): AppPageResponsePolicy;

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

@@ -1,7 +1,7 @@
-import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
+import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
 import { NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 //#region src/server/app-page-response.ts
 function applyTimingHeader(headers, timing) {
@@ -14,6 +14,14 @@ function applyTimingHeader(headers, timing) {
 function applyDynamicStaleTimeHeader(headers, dynamicStaleTimeSeconds) {
 	if (dynamicStaleTimeSeconds !== void 0 && Number.isInteger(dynamicStaleTimeSeconds) && dynamicStaleTimeSeconds >= 0) headers.set(VINEXT_DYNAMIC_STALE_TIME_HEADER, String(dynamicStaleTimeSeconds));
 }
+function applyPrerenderCacheLifeHeader(headers, requestCacheLife) {
+	if (!requestCacheLife) return;
+	const payload = {};
+	if (typeof requestCacheLife.revalidate === "number" && Number.isFinite(requestCacheLife.revalidate)) payload.revalidate = requestCacheLife.revalidate;
+	if (typeof requestCacheLife.expire === "number" && Number.isFinite(requestCacheLife.expire)) payload.expire = requestCacheLife.expire;
+	if (payload.revalidate === void 0 && payload.expire === void 0) return;
+	headers.set(VINEXT_PRERENDER_CACHE_LIFE_HEADER, JSON.stringify(payload));
+}
 function resolveAppPageRscResponsePolicy(options) {
 	if (options.isDraftMode) return { cacheControl: NO_STORE_CACHE_CONTROL };
 	if (options.isForceDynamic || options.dynamicUsedDuringBuild) return { cacheControl: NO_STORE_CACHE_CONTROL };
@@ -51,8 +59,8 @@ function resolveAppPageHtmlResponsePolicy(options) {
 	};
 	if ((options.isForceStatic || options.isDynamicError) && options.revalidateSeconds === null) return {
 		cacheControl: STATIC_CACHE_CONTROL,
-		cacheState: "STATIC",
-		shouldWriteToCache: false
+		cacheState: options.isProduction ? "MISS" : "STATIC",
+		shouldWriteToCache: options.isProduction
 	};
 	if (options.dynamicUsedDuringRender) return {
 		cacheControl: NO_STORE_CACHE_CONTROL,
@@ -92,7 +100,10 @@ function buildAppPageRscResponse(body, options) {
 	if (options.policy.cacheControl) headers.set("Cache-Control", options.policy.cacheControl);
 	if (options.policy.cacheState) setCacheStateHeaders(headers, options.policy.cacheState);
 	mergeMiddlewareResponseHeaders(headers, options.middlewareContext.headers);
+	if (options.renderedPathAndSearch) headers.set(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, encodeURIComponent(options.renderedPathAndSearch));
 	applyRscCompatibilityIdHeader(headers);
+	applyRscDeploymentIdHeader(headers);
+	applyPrerenderCacheLifeHeader(headers, options.requestCacheLife);
 	applyTimingHeader(headers, options.timing);
 	return new Response(body, {
 		status: options.middlewareContext.status ?? 200,
@@ -110,6 +121,7 @@ function buildAppPageHtmlResponse(body, options) {
 	if (options.draftCookie) headers.append("Set-Cookie", options.draftCookie);
 	if (options.linkHeader) headers.set("Link", options.linkHeader);
 	mergeMiddlewareResponseHeaders(headers, options.middlewareContext.headers);
+	applyPrerenderCacheLifeHeader(headers, options.requestCacheLife);
 	applyTimingHeader(headers, options.timing);
 	return new Response(body, {
 		status: options.middlewareContext.status ?? 200,

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

@@ -107,7 +107,8 @@ type RenderAppPageHtmlStreamOptions = {
     value: Promise<ArrayBuffer> | null;
   }; /** 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. */
+  waitForAllReady?: boolean; /** Override the default shell-error recovery decision passed to handleSsr. */
+  fallbackToErrorDocumentOnShellError?: 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

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

@@ -68,7 +68,7 @@ async function renderAppPageHtmlStream(options) {
 		pprFallbackShellSignal: options.pprFallbackShellSignal,
 		waitForAllReady: options.waitForAllReady,
 		initialDevServerError: options.initialDevServerError,
-		fallbackToErrorDocumentOnShellError: options.waitForAllReady !== true && options.hasCustomGlobalError === false,
+		fallbackToErrorDocumentOnShellError: options.fallbackToErrorDocumentOnShellError ?? (options.waitForAllReady !== true && options.hasCustomGlobalError === false),
 		dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
 		getInitialNavigationCacheMetadata: options.getInitialNavigationCacheMetadata
 	};

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

@@ -1,6 +1,6 @@
 import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
-import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { runWithRootParamsUsage } from "../shims/root-params.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
 import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";

package/dist/server/app-route-tree-prefetch.d.ts

@@ -0,0 +1,43 @@
+//#region src/server/app-route-tree-prefetch.d.ts
+type DynamicParamTypeShort = "d" | "c" | "oc";
+type TreePrefetchParam = {
+  type: DynamicParamTypeShort;
+  key: null;
+  siblings: readonly string[] | null;
+};
+type AppRouteTreePrefetchSlot = {
+  configLayouts?: readonly unknown[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
+  default?: unknown;
+  layout?: unknown;
+  layoutIndex?: number;
+  name: string;
+  page?: unknown;
+  routeSegments?: readonly string[] | null;
+};
+type AppRouteTreePrefetchRoute = {
+  layoutTreePositions?: readonly number[];
+  layouts?: readonly unknown[];
+  page?: unknown;
+  routeSegments: readonly string[];
+  slots?: Readonly<Record<string, AppRouteTreePrefetchSlot>> | null;
+};
+type TreePrefetch = {
+  name: string;
+  param: TreePrefetchParam | null;
+  prefetchHints: number;
+  slots: null | Record<string, TreePrefetch>;
+};
+type RouteTreePrefetchResponseOptions = {
+  buildId?: string | null;
+  deploymentId?: string;
+  prefetchInlining?: PrefetchInliningConfig;
+};
+type PrefetchInliningConfig = false | {
+  maxBundleSize: number;
+  maxSize: number;
+};
+declare function isRouteTreePrefetchRequest(request: Request): boolean;
+declare function createRouteTreePrefetchResponse(route: AppRouteTreePrefetchRoute, options?: RouteTreePrefetchResponseOptions): Promise<Response>;
+//#endregion
+export { AppRouteTreePrefetchRoute, PrefetchInliningConfig, TreePrefetch, createRouteTreePrefetchResponse, isRouteTreePrefetchRequest };

package/dist/server/app-route-tree-prefetch.js

@@ -0,0 +1,187 @@
+import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
+import { getDeploymentId } from "../utils/deployment-id.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+//#region src/server/app-route-tree-prefetch.ts
+const PARENT_INLINED_INTO_SELF = 32;
+const INLINED_INTO_CHILD = 64;
+const HEAD_INLINED_INTO_SELF = 128;
+const PAGE_SEGMENT = "__PAGE__";
+const SLOT_SEGMENT = "(__SLOT__)";
+const SEGMENT_INLINE_SIZE = 1;
+const SEGMENT_OUTLINE_SIZE = 4096;
+const DEFAULT_SEGMENT_INLINE_THRESHOLD = 2048;
+const HEAD_INLINE_SIZE = 1;
+const DEFAULT_MAX_INLINE_BUNDLE_SIZE = 10240;
+const NEXT_DID_POSTPONE_HEADER = "x-nextjs-postponed";
+function isRouteTreePrefetchRequest(request) {
+	return request.headers.get("RSC") === "1" && request.headers.get("Next-Router-Prefetch") === "1" && request.headers.get("Next-Router-Segment-Prefetch") === "/_tree";
+}
+function createNode(segment, module) {
+	const { name, param } = routeTreeSegment(segment);
+	return {
+		name,
+		param,
+		prefetchSize: estimatePrefetchSize(module) ?? ((module === null || module === void 0) && segment !== PAGE_SEGMENT ? SEGMENT_INLINE_SIZE : null),
+		prefetchHints: 0,
+		slots: null
+	};
+}
+function ensureSlots(node) {
+	if (node.slots === null) node.slots = {};
+	return node.slots;
+}
+function addChild(node, key, child) {
+	ensureSlots(node)[key] = child;
+}
+function routeTreeSegment(segment) {
+	if (segment.startsWith(":")) {
+		const rest = segment.slice(1);
+		if (rest.endsWith("+")) return dynamicRouteTreeSegment(rest.slice(0, -1), "c");
+		if (rest.endsWith("*")) return dynamicRouteTreeSegment(rest.slice(0, -1), "oc");
+		return dynamicRouteTreeSegment(rest, "d");
+	}
+	if (segment.startsWith("[[...") && segment.endsWith("]]")) return dynamicRouteTreeSegment(segment.slice(5, -2), "oc");
+	if (segment.startsWith("[...") && segment.endsWith("]")) return dynamicRouteTreeSegment(segment.slice(4, -1), "c");
+	if (segment.startsWith("[") && segment.endsWith("]")) return dynamicRouteTreeSegment(segment.slice(1, -1), "d");
+	return {
+		name: segment,
+		param: null
+	};
+}
+function dynamicRouteTreeSegment(name, type) {
+	return {
+		name,
+		param: {
+			key: null,
+			siblings: null,
+			type
+		}
+	};
+}
+function explicitPrefetchSize(module) {
+	if (typeof module !== "object" || module === null) return null;
+	const value = module.prefetchSize;
+	if (value === "large") return SEGMENT_OUTLINE_SIZE;
+	if (value === "small") return SEGMENT_INLINE_SIZE;
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function estimatePrefetchSize(module) {
+	const explicitSize = explicitPrefetchSize(module);
+	if (explicitSize !== null) return explicitSize;
+	if (typeof module !== "object" || module === null) return null;
+	return typeof module.default === "function" ? SEGMENT_INLINE_SIZE : null;
+}
+function layoutModuleByTreePosition(route) {
+	const layouts = route.layouts ?? [];
+	const positions = route.layoutTreePositions ?? [];
+	const byPosition = /* @__PURE__ */ new Map();
+	for (const [index, position] of positions.entries()) byPosition.set(position, layouts[index]);
+	return byPosition;
+}
+function modulesByTreePosition(modules, positions) {
+	const byPosition = /* @__PURE__ */ new Map();
+	for (const [index, position] of (positions ?? []).entries()) byPosition.set(position, modules?.[index]);
+	return byPosition;
+}
+async function buildTree(route) {
+	const layoutsByPosition = layoutModuleByTreePosition(route);
+	const root = createNode("", layoutsByPosition.get(0));
+	const nodesByPosition = new Map([[0, root]]);
+	let current = root;
+	for (const [index, segment] of route.routeSegments.entries()) {
+		const position = index + 1;
+		const child = createNode(segment, layoutsByPosition.get(position));
+		addChild(current, "children", child);
+		nodesByPosition.set(position, child);
+		current = child;
+	}
+	addChild(current, "children", createNode(PAGE_SEGMENT, route.page));
+	for (const slot of Object.values(route.slots ?? {})) {
+		const ownerPosition = slot.layoutIndex === void 0 || slot.layoutIndex < 0 ? route.routeSegments.length : route.layoutTreePositions?.[slot.layoutIndex] ?? route.routeSegments.length;
+		const owner = nodesByPosition.get(ownerPosition) ?? current;
+		const slotRoot = createNode(SLOT_SEGMENT, slot.layout);
+		let slotCurrent = slotRoot;
+		const slotConfigLayoutsByPosition = modulesByTreePosition(slot.configLayouts, slot.configLayoutTreePositions);
+		const slotRouteSegments = slot.routeSegments ?? [];
+		for (const [index, segment] of slotRouteSegments.entries()) {
+			const position = index + 1;
+			const child = createNode(segment, slotConfigLayoutsByPosition.get(position));
+			addChild(slotCurrent, "children", child);
+			slotCurrent = child;
+		}
+		addChild(slotCurrent, "children", createNode(PAGE_SEGMENT, slot.page ?? slot.default));
+		addChild(owner, slot.name, slotRoot);
+	}
+	return root;
+}
+function computePrefetchHints(node, parentGzipSize, headInlineState, config) {
+	const currentGzipSize = node.prefetchSize;
+	const sizeToInline = currentGzipSize !== null && currentGzipSize < config.maxSize ? currentGzipSize : null;
+	let didInlineIntoChild = false;
+	let acceptingChildInlinedBytes = 0;
+	let smallestChildInlinedBytes = Number.POSITIVE_INFINITY;
+	let hasChildren = false;
+	for (const child of Object.values(node.slots ?? {})) {
+		hasChildren = true;
+		const childInlinedBytes = computePrefetchHints(child, didInlineIntoChild ? null : sizeToInline, headInlineState, config);
+		if ((child.prefetchHints & PARENT_INLINED_INTO_SELF) !== 0) {
+			didInlineIntoChild = true;
+			acceptingChildInlinedBytes = childInlinedBytes;
+		} else if (!didInlineIntoChild && childInlinedBytes < smallestChildInlinedBytes) smallestChildInlinedBytes = childInlinedBytes;
+	}
+	if (!hasChildren) smallestChildInlinedBytes = 0;
+	let hints = node.prefetchHints;
+	if (didInlineIntoChild) hints |= INLINED_INTO_CHILD;
+	let inlinedBytes = didInlineIntoChild ? acceptingChildInlinedBytes : smallestChildInlinedBytes;
+	const isBundleTerminal = !didInlineIntoChild;
+	if (!headInlineState.inlined && isBundleTerminal && node.name === PAGE_SEGMENT && inlinedBytes + HEAD_INLINE_SIZE < config.maxBundleSize) {
+		hints |= HEAD_INLINED_INTO_SELF;
+		inlinedBytes += HEAD_INLINE_SIZE;
+		headInlineState.inlined = true;
+	}
+	if (parentGzipSize !== null) {
+		if (inlinedBytes + parentGzipSize < config.maxBundleSize) {
+			hints |= PARENT_INLINED_INTO_SELF;
+			inlinedBytes += parentGzipSize;
+		}
+	}
+	node.prefetchHints = hints;
+	return inlinedBytes;
+}
+function stripMutableFields(node) {
+	const slots = node.slots === null ? null : Object.fromEntries(Object.entries(node.slots).map(([key, child]) => [key, stripMutableFields(child)]));
+	return {
+		name: node.name,
+		param: node.param,
+		prefetchHints: node.prefetchHints,
+		slots
+	};
+}
+function resolvePrefetchInliningConfig(config) {
+	if (config) return config;
+	return {
+		maxBundleSize: DEFAULT_MAX_INLINE_BUNDLE_SIZE,
+		maxSize: DEFAULT_SEGMENT_INLINE_THRESHOLD
+	};
+}
+async function createRouteTreePrefetchResponse(route, options = {}) {
+	const tree = await buildTree(route);
+	computePrefetchHints(tree, null, { inlined: false }, resolvePrefetchInliningConfig(options.prefetchInlining));
+	const headers = new Headers({
+		"Cache-Control": "no-store",
+		"Content-Type": VINEXT_RSC_CONTENT_TYPE,
+		[NEXT_DID_POSTPONE_HEADER]: "2",
+		Vary: VINEXT_RSC_VARY_HEADER
+	});
+	applyRscCompatibilityIdHeader(headers);
+	const deploymentId = options.deploymentId ?? getDeploymentId();
+	if (deploymentId) headers.set(NEXTJS_DEPLOYMENT_ID_HEADER, deploymentId);
+	const payload = {
+		tree: stripMutableFields(tree),
+		staleTime: -1
+	};
+	if (options.buildId) payload.buildId = options.buildId;
+	return new Response(`0:${JSON.stringify(payload)}\n`, { headers });
+}
+//#endregion
+export { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest };

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

@@ -4,8 +4,8 @@ import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "../utils/protocol-headers.
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
-import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
+import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import rscHandler, { __assetPrefix, __basePath, __imageAllowedWidths, __imageConfig } from "virtual:vinext-rsc-entry";

package/dist/server/app-rsc-cache-busting.d.ts

@@ -24,6 +24,7 @@ type ResolveInvalidRscCacheBustingRequestOptions = {
 };
 declare function getVinextRscCompatibilityId(): string | null;
 declare function applyRscCompatibilityIdHeader(headers: Headers, compatibilityId?: string | null | undefined): void;
+declare function applyRscDeploymentIdHeader(headers: Headers): void;
 declare function isRscCompatibilityIdCompatible(responseCompatibilityId: string | null | undefined, clientCompatibilityId?: string | null | undefined): boolean;
 type RscCompatibilityNavigationDecision = {
   kind: "compatible";
@@ -61,4 +62,4 @@ declare function createServerActionRequestUrl(href: string): string;
 declare function createRscRedirectLocation(location: string, request: Request): Promise<string>;
 declare function resolveInvalidRscCacheBustingRequest(options: ResolveInvalidRscCacheBustingRequestOptions): Promise<Response | null>;
 //#endregion
-export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

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

@@ -1,7 +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 { NEXTJS_DEPLOYMENT_ID_HEADER, 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";
+import { applyDeploymentIdHeader, getDeploymentId } 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.
@@ -44,6 +44,11 @@ function applyRscCompatibilityIdHeader(headers, compatibilityId = getVinextRscCo
 	if (normalized) headers.set(VINEXT_RSC_COMPATIBILITY_ID_HEADER, normalized);
 	else headers.delete(VINEXT_RSC_COMPATIBILITY_ID_HEADER);
 }
+function applyRscDeploymentIdHeader(headers) {
+	const deploymentId = getDeploymentId();
+	if (deploymentId) headers.set(NEXTJS_DEPLOYMENT_ID_HEADER, deploymentId);
+	else headers.delete(NEXTJS_DEPLOYMENT_ID_HEADER);
+}
 function isRscCompatibilityIdCompatible(responseCompatibilityId, clientCompatibilityId = getVinextRscCompatibilityId()) {
 	const normalizedResponseCompatibilityId = normalizeCompatibilityId(responseCompatibilityId);
 	const normalizedClientCompatibilityId = normalizeCompatibilityId(clientCompatibilityId);
@@ -184,7 +189,7 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	const url = new URL(options.request.url);
 	const actualHash = url.searchParams.get(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
 	const expectedHash = await computeRscCacheBustingSearchParam(options.request.headers);
-	if (actualHash === null && expectedHash === "") return null;
+	if (actualHash === null && expectedHash === "" && url.pathname.endsWith(".rsc")) return null;
 	const acceptedHashes = new Set([expectedHash]);
 	if (actualHash !== null && actualHash !== expectedHash) {
 		acceptedHashes.add(computeLegacyRscCacheBustingSearchParam(options.request.headers));
@@ -203,4 +208,4 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	});
 }
 //#endregion
-export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

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

@@ -6,6 +6,7 @@ import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
+import { AppRouteTreePrefetchRoute, PrefetchInliningConfig } from "./app-route-tree-prefetch.js";
 import { ReactFormState } from "react-dom/client";
 
 //#region src/server/app-rsc-handler.d.ts
@@ -24,12 +25,15 @@ type AppRscHandlerRoute = {
   __loadPage?: unknown;
   __loadRouteHandler?: unknown;
   isDynamic: boolean;
+  layouts?: readonly unknown[];
+  layoutTreePositions?: readonly number[];
   params?: readonly string[];
   page?: unknown;
   pattern: string;
   rootParamNames?: readonly string[];
   routeHandler?: unknown;
   routeSegments: readonly string[];
+  slots?: AppRouteTreePrefetchRoute["slots"];
 };
 type AppRscRouteMatch<TRoute> = {
   params: AppPageParams;
@@ -63,6 +67,7 @@ type DispatchMatchedPageOptions<TRoute> = {
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
   request: Request;
+  renderedPathAndSearch?: string | null;
   route: TRoute;
   scriptNonce?: string;
   searchParams: URLSearchParams;
@@ -189,6 +194,7 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   runMiddleware?: (options: RunAppMiddlewareOptions) => Promise<ApplyAppMiddlewareResult>;
   publicFiles: ReadonlySet<string>;
+  prefetchInlining?: PrefetchInliningConfig;
   renderNotFound: (options: RenderNotFoundOptions<TRoute>) => Promise<Response | null>;
   renderPagesFallback?: (options: RenderPagesFallbackOptions) => Promise<Response | null>;
   rootParamNamesByPattern?: RootParamNamesMap;