vinext 0.1.8 → 0.2.1

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

@@ -1,12 +1,13 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
+import "../utils/protocol-headers.js";
 import { AppElementsWire } from "./app-elements-wire.js";
-import { shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
+import { APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
 import "./app-elements.js";
 import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersContext, isDraftModeRequest, markDynamicUsage, peekDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife, _peekRequestScopedCacheLife } from "../shims/cache-request-state.js";
-import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground } from "../shims/fetch-cache.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";
 import "./app-page-response.js";
 import { buildAppPageSpecialErrorResponse, probeAppPageThrownError, resolveAppPageSpecialError } from "./app-page-execution.js";
@@ -100,6 +101,10 @@ function getEffectiveLayoutClassifications(route, debugClassification) {
 function shouldReadAppPageCache(options) {
 	return options.isProduction && !options.isProgressiveActionRender && !options.isDraftMode && !options.isForceDynamic && (options.isRscRequest || !options.scriptNonce) && (options.revalidateSeconds === null || options.revalidateSeconds > 0);
 }
+function resolveAppPageCacheReadRevalidateSeconds(options) {
+	if (options.revalidateSeconds === null && (options.isForceStatic || options.isDynamicError)) return Infinity;
+	return options.revalidateSeconds ?? 0;
+}
 function hasSearchParams(searchParams) {
 	return searchParams !== null && searchParams !== void 0 && searchParams.size > 0;
 }
@@ -119,6 +124,7 @@ async function runAppPageRevalidationContext(options, renderFn) {
 		unstableCacheRevalidation: "foreground"
 	}), async () => {
 		ensureFetchPatch();
+		setRefreshStaleFetchesInForeground(process.env.VINEXT_PRERENDER === "1");
 		setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], options.routeSegments));
 		options.setNavigationContext({
 			pathname: options.displayPathname ?? options.cleanPathname,
@@ -154,10 +160,12 @@ async function dispatchAppPageInner(options) {
 	const isForceStatic = dynamicConfig === "force-static";
 	const isDynamicError = dynamicConfig === "error";
 	const isForceDynamic = dynamicConfig === "force-dynamic";
+	const isPrefetchDynamicShell = options.renderMode === APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL;
 	const isDraftMode = isDraftModeRequest(options.request, options.draftModeSecret);
 	const requestHeadersContext = getHeadersContext();
-	const hasRequestSearchParams = !isForceStatic && hasSearchParams(options.searchParams);
-	const pageSearchParams = isForceStatic ? new URLSearchParams() : options.searchParams;
+	const shouldUseEmptySearchParams = isForceStatic || isPrefetchDynamicShell;
+	const hasRequestSearchParams = !shouldUseEmptySearchParams && hasSearchParams(options.searchParams);
+	const pageSearchParams = shouldUseEmptySearchParams ? new URLSearchParams() : options.searchParams;
 	const layoutParamAccess = createAppLayoutParamAccessTracker();
 	const hasActiveLoadingBoundary = shouldSuppressLoadingBoundaries(options.renderMode ?? "navigation") ? false : Boolean(route.loading?.default);
 	setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], route.routeSegments));
@@ -222,7 +230,11 @@ async function dispatchAppPageInner(options) {
 			mountedSlotsHeader: options.mountedSlotsHeader,
 			renderMode: options.renderMode,
 			expireSeconds: options.expireSeconds,
-			revalidateSeconds: currentRevalidateSeconds ?? 0,
+			revalidateSeconds: resolveAppPageCacheReadRevalidateSeconds({
+				isDynamicError,
+				isForceStatic,
+				revalidateSeconds: currentRevalidateSeconds
+			}),
 			renderFreshPageForCache: async () => {
 				const revalidationTarget = await resolveAppPageInterceptionRerenderTarget({
 					cleanPathname: options.cleanPathname,
@@ -284,6 +296,7 @@ async function dispatchAppPageInner(options) {
 					return {
 						html: rendered.html,
 						htmlRenderObservation: rendered.htmlRenderObservation,
+						linkHeader: rendered.linkHeader,
 						rscData: rendered.rscData,
 						rscRenderObservation: rendered.rscRenderObservation,
 						tags: rendered.tags,
@@ -360,6 +373,7 @@ async function dispatchAppPageInner(options) {
 			});
 			mergeMiddlewareResponseHeaders(interceptHeaders, options.middlewareContext.headers);
 			applyRscCompatibilityIdHeader(interceptHeaders);
+			applyRscDeploymentIdHeader(interceptHeaders);
 			return new Response(interceptStream, {
 				status: options.middlewareContext.status ?? 200,
 				headers: interceptHeaders
@@ -427,6 +441,8 @@ async function dispatchAppPageInner(options) {
 	const activeFallbackShellState = options.pprRuntime?.getState() ?? null;
 	const pprFallbackShellSignal = activeFallbackShellState?.abortController.signal;
 	const pprFallbackShellReactSignal = activeFallbackShellState?.reactAbortController.signal;
+	const isPrerender = process.env.VINEXT_PRERENDER === "1";
+	const isSpeculativePrerender = isPrerender && options.request.headers.get("x-vinext-prerender-speculative") === "1";
 	return renderAppPageLifecycle({
 		basePath: options.basePath,
 		clientTraceMetadata: options.clientTraceMetadata,
@@ -458,7 +474,7 @@ async function dispatchAppPageInner(options) {
 		},
 		handlerStart: options.handlerStart,
 		hasLoadingBoundary: hasActiveLoadingBoundary,
-		omitPendingDynamicCacheState: !options.isRscRequest && hasRequestSearchParams,
+		omitPendingDynamicCacheState: hasRequestSearchParams,
 		formState: options.formState ?? null,
 		isProgressiveActionRender: options.isProgressiveActionRender === true,
 		isDynamicError,
@@ -466,7 +482,8 @@ async function dispatchAppPageInner(options) {
 		isForceDynamic,
 		isForceStatic,
 		isEdgeRuntime: options.isEdgeRuntime === true,
-		isPrerender: process.env.VINEXT_PRERENDER === "1",
+		isPrerender,
+		isSpeculativePrerender,
 		isProduction: options.isProduction,
 		isRscRequest: options.isRscRequest,
 		isrDebug: options.isrDebug,
@@ -482,6 +499,7 @@ async function dispatchAppPageInner(options) {
 		params: options.params,
 		pprFallbackShellSignal,
 		pprFallbackShellReactSignal,
+		renderedPathAndSearch: options.renderedPathAndSearch,
 		abortPprFallbackShell: activeFallbackShellState ? () => {
 			options.pprRuntime.beginFinalRender(activeFallbackShellState);
 		} : void 0,

package/dist/server/app-page-element-builder.d.ts

@@ -95,6 +95,7 @@ type AppPageNavigationParamInterceptOptions = {
  * {@link https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/create-metadata.tsx|create-metadata.tsx}.
  */
 declare function buildPageElements<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule>(options: BuildPageElementsOptions<TModule, TErrorModule>): Promise<AppElements>;
+declare function resolveInterceptedSlotSegments(sourcePageSegments: readonly string[] | null | undefined, slotKey: string): readonly string[] | null;
 declare function resolveAppPageNavigationParams(route: AppPageNavigationParamRoute, routeParams: AppPageParams, routePath: string, opts?: AppPageNavigationParamInterceptOptions | null): AppPageParams;
 //#endregion
-export { AppPageBuildRoute, type AppPageErrorModule, AppPageInterceptOptions, AppPagePageRequest, type AppPageRouteWiringRoute, BuildPageElementsOptions, buildPageElements, resolveAppPageNavigationParams };
+export { AppPageBuildRoute, type AppPageErrorModule, AppPageInterceptOptions, AppPagePageRequest, type AppPageRouteWiringRoute, BuildPageElementsOptions, buildPageElements, resolveAppPageNavigationParams, resolveInterceptedSlotSegments };

package/dist/server/app-page-element-builder.js

@@ -1,8 +1,8 @@
-import { matchRoutePattern } from "../routing/route-pattern.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION } from "./app-rsc-render-mode.js";
 import "./app-elements.js";
 import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import { resolveAppPageBranchParams } from "./app-page-params.js";
 import { resolveActiveParallelRouteHeadInputs, resolveAppPageHead } from "./app-page-head.js";
@@ -51,6 +51,8 @@ async function buildPageElements(options) {
 	const hasPageModule = !!pageModule;
 	const renderIdentity = createAppPageRenderIdentity({
 		displayPathname,
+		matchedRoutePathname: routePath,
+		targetMatchedPathname: routePath,
 		interceptionContext: opts?.interceptionContext ?? null,
 		interceptSourceMatchedUrl: opts?.interceptSourceMatchedUrl ?? null,
 		interceptSlotId: isSiblingIntercept ? null : opts?.interceptSlotId ?? null
@@ -181,18 +183,71 @@ function buildSlotOverrides(route, routeParams, routePath, opts) {
 		layoutModules: opts.interceptLayouts || null,
 		layoutSegments: opts.interceptLayoutSegments ?? null,
 		pageModule: opts.interceptPage,
-		params: opts.interceptParams || routeParams
+		params: opts.interceptParams || routeParams,
+		routeSegments: resolveInterceptedSlotSegments(opts.interceptSourcePageSegments, opts.interceptSlotKey)
 	};
 	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
 	for (const [slotKey, params] of Object.entries(slotParamOverrides ?? {})) {
 		const existing = overrides[slotKey];
 		overrides[slotKey] = existing ? {
 			...existing,
-			params
+			params: existing.params ?? params
 		} : { params };
 	}
 	return Object.keys(overrides).length > 0 ? overrides : null;
 }
+function resolveInterceptedSlotSegments(sourcePageSegments, slotKey) {
+	if (!sourcePageSegments) return null;
+	const markerTraversals = [
+		{
+			prefix: "(...)",
+			levels: Number.POSITIVE_INFINITY
+		},
+		{
+			prefix: "(..)(..)",
+			levels: 2
+		},
+		{
+			prefix: "(..)",
+			levels: 1
+		},
+		{
+			prefix: "(.)",
+			levels: 0
+		}
+	];
+	const markerIndex = sourcePageSegments.findIndex((segment) => markerTraversals.some(({ prefix }) => segment.startsWith(prefix)));
+	if (markerIndex < 0) return null;
+	const slotPathSeparator = slotKey.indexOf("@");
+	const ownerSegments = (slotPathSeparator >= 0 ? slotKey.slice(slotPathSeparator + 1) : "").split("/").filter(Boolean);
+	let segmentStart = ownerSegments.length;
+	if (segmentStart === 0 || segmentStart > markerIndex || !ownerSegments.every((segment, index) => sourcePageSegments[index] === segment)) {
+		let slotName = null;
+		for (let index = ownerSegments.length - 1; index >= 0; index--) if (ownerSegments[index].startsWith("@")) {
+			slotName = ownerSegments[index];
+			break;
+		}
+		let slotIndex = -1;
+		if (slotName) {
+			for (let index = markerIndex - 1; index >= 0; index--) if (sourcePageSegments[index] === slotName) {
+				slotIndex = index;
+				break;
+			}
+		}
+		if (slotIndex < 0) return null;
+		segmentStart = slotIndex + 1;
+	}
+	const routeSegments = sourcePageSegments.slice(segmentStart, markerIndex).filter((segment) => !segment.startsWith("@") && !(segment.startsWith("(") && segment.endsWith(")")));
+	const markerSegment = sourcePageSegments[markerIndex];
+	const marker = markerTraversals.find(({ prefix }) => markerSegment.startsWith(prefix));
+	if (!marker) return null;
+	if (Number.isFinite(marker.levels)) routeSegments.splice(Math.max(0, routeSegments.length - marker.levels), marker.levels);
+	else routeSegments.length = 0;
+	const targetSegment = markerSegment.slice(marker.prefix.length);
+	if (targetSegment) routeSegments.push(targetSegment);
+	routeSegments.push(...sourcePageSegments.slice(markerIndex + 1).filter((segment) => !segment.startsWith("@") && !(segment.startsWith("(") && segment.endsWith(")"))));
+	return routeSegments;
+}
 function resolveSlotParamOverrides(route, routePath) {
 	const overrides = {};
 	const slots = route.slots;
@@ -238,4 +293,4 @@ function collectParamNameSet(params) {
 	return set;
 }
 //#endregion
-export { buildPageElements, resolveAppPageNavigationParams };
+export { buildPageElements, resolveAppPageNavigationParams, resolveInterceptedSlotSegments };

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

@@ -1,7 +1,7 @@
 import { addBasePathToPathname } from "../utils/base-path.js";
 import { VINEXT_RSC_REDIRECT_HEADER } from "./headers.js";
 import { runWithConnectionProbe } from "../shims/headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
@@ -161,6 +161,7 @@ async function buildAppPageSpecialErrorResponse(options) {
 			});
 			applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
 			applyRscCompatibilityIdHeader(headers);
+			applyRscDeploymentIdHeader(headers);
 			mergeMiddlewareResponseHeaders(headers, options.middlewareContext?.headers ?? null);
 			const pendingCookies = options.getAndClearPendingCookies?.() ?? [];
 			for (const cookie of pendingCookies) headers.append("Set-Cookie", cookie);

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

@@ -12,6 +12,7 @@ const DEFAULT_SUBTREE_PROBE_MAX_NODES = 1e3;
 const REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
 const REACT_LAZY_TYPE = Symbol.for("react.lazy");
 const REACT_MEMO_TYPE = Symbol.for("react.memo");
+const REACT_CLIENT_REFERENCE_TYPE = Symbol.for("react.client.reference");
 var AppPageSubtreeProbeLimitError = class extends Error {
 	constructor(message) {
 		super(message);
@@ -36,6 +37,9 @@ function isObjectLike(value) {
 function isUnknownFunction(value) {
 	return typeof value === "function";
 }
+function isReactClientReference(value) {
+	return isObjectLike(value) && Reflect.get(value, "$$typeof") === REACT_CLIENT_REFERENCE_TYPE;
+}
 function readReactMemoType(value) {
 	if (!isObjectLike(value) || Reflect.get(value, "$$typeof") !== REACT_MEMO_TYPE) return null;
 	return { innerType: Reflect.get(value, "type") };
@@ -80,6 +84,7 @@ async function probeReactServerSubtree(node, options = {}) {
 	};
 	const renderElementType = async (type, props, depth, wrapperDepth = 0) => {
 		if (wrapperDepth > maxDepth) throw new AppPageSubtreeProbeLimitError("App page layout subtree probe exceeded max depth");
+		if (isReactClientReference(type)) return false;
 		if (isUnknownFunction(type)) {
 			await visit(type(props), depth + 1);
 			return true;

package/dist/server/app-page-render-identity.d.ts

@@ -2,6 +2,8 @@ import { AppElementsInterception } from "./app-elements-wire.js";
 //#region src/server/app-page-render-identity.d.ts
 type AppPageRenderIdentityInput = {
   displayPathname: string;
+  matchedRoutePathname?: string;
+  targetMatchedPathname?: string;
   interceptionContext?: string | null;
   interceptSourceMatchedUrl?: string | null;
   interceptSlotId?: string | null;

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

@@ -13,10 +13,11 @@ function normalizeAppPageInterceptionProofPathname(pathname) {
 }
 function createAppPageRenderIdentity(input) {
 	const interceptionContext = input.interceptionContext ?? null;
-	const targetMatchedPathname = normalizeAppPageRenderMatchedPathname(input.displayPathname);
+	const targetMatchedPathname = normalizeAppPageRenderMatchedPathname(input.targetMatchedPathname ?? input.displayPathname);
+	const requestedMatchedRoutePathname = normalizeAppPageRenderMatchedPathname(input.matchedRoutePathname ?? input.targetMatchedPathname ?? input.displayPathname);
 	const sourceMatchedPathname = normalizeAppPageInterceptionProofPathname(input.interceptSourceMatchedUrl ?? null);
 	const slotId = input.interceptSlotId ?? null;
-	const matchedRoutePathname = sourceMatchedPathname ?? targetMatchedPathname;
+	const matchedRoutePathname = sourceMatchedPathname ?? requestedMatchedRoutePathname;
 	const routeId = AppElementsWire.encodeRouteId(matchedRoutePathname, null);
 	const pageId = AppElementsWire.encodePageId(matchedRoutePathname, null);
 	const interception = sourceMatchedPathname === null || slotId === null ? null : {

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

@@ -60,6 +60,7 @@ type RenderAppPageLifecycleOptions = {
   isForceStatic: boolean;
   isProgressiveActionRender?: boolean;
   isPrerender?: boolean;
+  isSpeculativePrerender?: boolean;
   isProduction: boolean;
   probePageBeforeRender?: boolean;
   omitPendingDynamicCacheState?: boolean;
@@ -103,6 +104,7 @@ type RenderAppPageLifecycleOptions = {
   clientReuseManifest?: ClientReuseManifestParseResult;
   skipDisposition?: ClientReuseManifestSkipDisposition;
   mountedSlotsHeader?: string | null;
+  renderedPathAndSearch?: string | null;
   renderMode?: AppRscRenderMode;
   waitUntil?: (promise: Promise<void>) => void;
   layoutParamAccess?: AppLayoutParamAccessTracker;

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

@@ -2,6 +2,7 @@ import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders }
 import { createArtifactCompatibilityEnvelope, createArtifactCompatibilityGraphVersion } from "./artifact-compatibility.js";
 import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { peekDynamicUsage } from "../shims/headers.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { buildAppPageHtmlResponse, buildAppPageRscResponse, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy } from "./app-page-response.js";
 import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageSpecialError, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
@@ -26,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;
@@ -39,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;
@@ -314,6 +325,7 @@ async function renderAppPageLifecycle(options) {
 	const outgoingElement = AppElementsWire.encodeOutgoingPayload({
 		element: options.element,
 		layoutFlags,
+		...options.dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true && !options.isForceStatic ? { dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds } : {},
 		...artifactCompatibility ? { artifactCompatibility } : {},
 		renderObservation: payloadRenderObservation,
 		skipDisposition: options.isRscRequest ? skipDisposition : void 0
@@ -336,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);
@@ -349,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
 			}));
 		}
@@ -376,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,
@@ -405,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);
 			}
@@ -427,6 +450,7 @@ async function renderAppPageLifecycle(options) {
 		getStyles: options.getFontStyles
 	});
 	const fontLinkHeader = buildAppPageFontLinkHeader(fontData.preloads);
+	let dynamicUsedDuringHtmlRender = false;
 	let renderEnd;
 	const htmlRender = await renderAppPageHtmlStreamWithRecovery({
 		onShellRendered() {
@@ -440,6 +464,19 @@ async function renderAppPageLifecycle(options) {
 			const ssrHandler = await options.loadSsrHandler();
 			return renderAppPageHtmlStream({
 				capturedRscDataRef,
+				getInitialNavigationCacheMetadata: () => {
+					let kind;
+					if (options.isForceStatic) kind = "static";
+					else if (options.isForceDynamic || dynamicUsedDuringHtmlRender || peekDynamicUsage()) kind = "dynamic";
+					else {
+						const observation = options.peekRenderObservationState?.();
+						kind = observation && (observation.dynamicFetches.length > 0 || observation.requestApis.length > 0) ? "dynamic" : "static";
+					}
+					return {
+						kind,
+						...kind === "dynamic" && options.dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true && !shouldCaptureRscForCacheMetadata ? { dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds } : {}
+					};
+				},
 				fontData,
 				hasCustomGlobalError: options.hasCustomGlobalError,
 				navigationContext: options.getNavigationContext(),
@@ -453,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) {
@@ -476,19 +514,33 @@ 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;
 	const safeHtmlStream = deferUntilStreamConsumed(htmlStream, () => {
 		dynamicUsedBeforeContextCleanup = dynamicUsedBeforeContextCleanup || options.consumeDynamicUsage();
+		dynamicUsedDuringHtmlRender = dynamicUsedBeforeContextCleanup;
 		options.clearRequestContext();
 	});
 	const htmlResponsePolicy = resolveAppPageHtmlResponsePolicy({
@@ -520,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,
@@ -533,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;
@@ -572,7 +626,7 @@ async function renderAppPageLifecycle(options) {
 				return options.getPageTags();
 			},
 			getRequestCacheLife() {
-				return options.getRequestCacheLife();
+				return readRequestCacheLifeForCachePolicy(options);
 			},
 			isrDebug: options.isrDebug,
 			isrHtmlKey: options.isrHtmlKey,
@@ -582,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);
 			}
@@ -594,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-request.d.ts

@@ -12,8 +12,20 @@ type GenerateStaticParamsModule = {
 };
 type GenerateStaticParamsSource = {
   generateStaticParams: GenerateStaticParams;
+  paramAliases?: Readonly<Record<string, string>>;
+  paramPatternParts?: readonly string[];
+  routePatternParts?: readonly string[];
   parentParamNames: readonly string[];
 };
+type ParallelGenerateStaticParamsBranch = {
+  configLayouts?: readonly (GenerateStaticParamsModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
+  layout?: GenerateStaticParamsModule | null;
+  page?: GenerateStaticParamsModule | null;
+  paramNames?: readonly string[] | null;
+  patternParts?: readonly string[] | null;
+  routeSegments?: readonly string[] | null;
+};
 type ValidateAppPageDynamicParamsOptions = {
   clearRequestContext: () => void;
   enforceStaticParamsOnly: boolean;
@@ -25,6 +37,8 @@ type ResolveAppPageGenerateStaticParamsSourcesOptions = {
   layouts?: readonly (GenerateStaticParamsModule | null | undefined)[];
   layoutTreePositions?: readonly number[];
   page?: GenerateStaticParamsModule | null;
+  parallelBranches?: readonly (ParallelGenerateStaticParamsBranch | null | undefined)[];
+  routePatternParts?: readonly string[];
   routeSegments: readonly string[];
 };
 type BuildAppPageElementOptions<TElement> = {