vinext 0.0.54 → 0.1.0

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

@@ -2,13 +2,18 @@ import { createArtifactCompatibilityEnvelope, createArtifactCompatibilityGraphVe
 import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
+import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
 import { buildAppPageHtmlResponse, buildAppPageRscResponse, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy } from "./app-page-response.js";
 import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageSpecialError, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
-import { createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError } from "./app-page-stream.js";
+import { probeAppPageBeforeRender } from "./app-page-probe.js";
+import { DEFAULT_CACHE_VARIANT_BUDGET, buildCacheVariantWithRouteBudget, buildRenderObservation, buildRenderRequestApiObservations, createStaticLayoutArtifactReuseDecision } from "./cache-proof.js";
 import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
 import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache.js";
+import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
+import { createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError } from "./app-page-stream.js";
+import { getStaticLayoutObservationSkipRejection } from "./app-layout-param-observation.js";
 import { hasDigest } from "./app-rsc-errors.js";
-import { probeAppPageBeforeRender } from "./app-page-probe.js";
+import { createClientReuseSkipTransportPlan, crossCheckClientReuseManifestEntryWithCache } from "./skip-cache-proof.js";
 //#region src/server/app-page-render.ts
 function buildResponseTiming(options) {
 	if (options.isProduction) return;
@@ -49,6 +54,146 @@ function createAppPageArtifactCompatibility(element, routePattern) {
 		rootBoundaryId
 	});
 }
+function readStringMetadata(element, key) {
+	const value = element[key];
+	return typeof value === "string" ? value : null;
+}
+function createStaticLayoutOutputScope(input) {
+	const routeId = readStringMetadata(input.element, AppElementsWire.keys.route);
+	if (routeId === null) return null;
+	return {
+		kind: "layout",
+		layoutId: input.layoutId,
+		rootBoundaryId: input.artifactCompatibility.rootBoundaryId,
+		routeId
+	};
+}
+function createRenderAndSendSkipDisposition() {
+	return {
+		code: "SKIP_MODEL_DISABLED",
+		enabled: false,
+		mode: "renderAndSend"
+	};
+}
+function rejectStaticLayoutObservation(entry, code, fields = {}) {
+	return {
+		kind: "rejected",
+		rejection: {
+			code,
+			entryId: entry.id,
+			fields
+		},
+		skipDisposition: createRenderAndSendSkipDisposition()
+	};
+}
+function rejectUnsafeStaticLayoutObservation(entry, layoutParamAccess) {
+	const observation = layoutParamAccess?.getLayoutObservation(entry.id);
+	if (!observation) return rejectStaticLayoutObservation(entry, "SKIP_LAYOUT_PARAMS_OBSERVATION_INCOMPLETE");
+	const observationRejection = getStaticLayoutObservationSkipRejection(observation);
+	if (observationRejection) return rejectStaticLayoutObservation(entry, observationRejection.code, observationRejection.fields);
+	return null;
+}
+function createRenderLifecycleSkipDisposition(input) {
+	if (!input.isRscRequest || input.clientReuseManifest === void 0) return;
+	const clientReuseManifest = input.clientReuseManifest;
+	if (clientReuseManifest.kind !== "parsed" || clientReuseManifest.manifest.entries.length === 0) return;
+	if (!isAppElementsRecord(input.element) || input.artifactCompatibility === void 0) return {
+		code: "SKIP_MODEL_DISABLED",
+		enabled: false,
+		mode: "renderAndSend"
+	};
+	const element = input.element;
+	const artifactCompatibility = input.artifactCompatibility;
+	const staticLayoutIds = new Set(Object.entries(input.layoutFlags).filter(([, flag]) => flag === "s").map(([layoutId]) => layoutId));
+	return createClientReuseSkipTransportPlan({
+		manifest: clientReuseManifest,
+		verifyEntry(entry) {
+			if (entry.kind !== "layout" || !staticLayoutIds.has(entry.id) || AppElementsWire.parseElementKey(entry.id)?.kind !== "layout") return crossCheckClientReuseManifestEntryWithCache({
+				artifact: {
+					compatibility: artifactCompatibility,
+					invalidation: { kind: "unknown" },
+					payloadHash: null
+				},
+				cacheDecision: null,
+				entry
+			});
+			const currentOutput = createStaticLayoutOutputScope({
+				artifactCompatibility,
+				element,
+				layoutId: entry.id
+			});
+			if (currentOutput === null) return crossCheckClientReuseManifestEntryWithCache({
+				artifact: {
+					compatibility: artifactCompatibility,
+					invalidation: { kind: "unknown" },
+					payloadHash: null
+				},
+				cacheDecision: null,
+				entry
+			});
+			const observationRejection = rejectUnsafeStaticLayoutObservation(entry, input.layoutParamAccess);
+			if (observationRejection) return observationRejection;
+			const candidateRouteId = createStaticLayoutClientReuseRouteId(entry.id);
+			const candidateOutput = {
+				...currentOutput,
+				routeId: candidateRouteId
+			};
+			const candidateVariant = buildCacheVariantWithRouteBudget({
+				budget: DEFAULT_CACHE_VARIANT_BUDGET,
+				dimensions: [],
+				output: candidateOutput,
+				routeBudget: {
+					routeId: candidateRouteId,
+					variantCacheKeys: []
+				}
+			});
+			const skipArtifactCompatibility = candidateVariant.kind === "variant" ? createStaticLayoutClientReuseArtifactCompatibility({
+				artifactCompatibility,
+				layoutId: entry.id,
+				rootBoundaryId: candidateOutput.rootBoundaryId,
+				routeId: candidateOutput.routeId,
+				variantCacheKey: candidateVariant.variant.cacheKey
+			}) : artifactCompatibility;
+			const cacheDecision = createStaticLayoutArtifactReuseDecision({
+				candidateArtifactCompatibility: skipArtifactCompatibility,
+				candidateObservation: buildRenderObservation({
+					boundaryOutcome: { kind: "success" },
+					cacheability: "public",
+					cacheTags: [],
+					completeness: "complete",
+					dynamicFetches: [],
+					output: candidateOutput,
+					pathTags: [input.cleanPathname],
+					requestApis: buildRenderRequestApiObservations({
+						completeness: "complete",
+						observed: []
+					})
+				}),
+				candidateVariant,
+				currentArtifactCompatibility: skipArtifactCompatibility,
+				currentOutput
+			});
+			return crossCheckClientReuseManifestEntryWithCache({
+				artifact: {
+					compatibility: skipArtifactCompatibility,
+					invalidation: { kind: "valid" },
+					payloadHash: candidateVariant.kind === "variant" ? createStaticLayoutClientReusePayloadHash({
+						artifactCompatibility: skipArtifactCompatibility,
+						layoutId: entry.id,
+						rootBoundaryId: candidateOutput.rootBoundaryId,
+						routeId: candidateOutput.routeId,
+						variantCacheKey: candidateVariant.variant.cacheKey
+					}) : null
+				},
+				cacheDecision,
+				entry
+			});
+		}
+	}).skipDisposition;
+}
+function isSkipTransportEnabled(skipDisposition) {
+	return skipDisposition?.enabled === true;
+}
 /**
 * Wraps an RSC response body to report invalid dynamic usage errors after the
 * stream is fully consumed. In dev mode, errors from cookies()/headers() inside
@@ -151,18 +296,29 @@ async function renderAppPageLifecycle(options) {
 		params: options.params,
 		state: options.peekRenderObservationState?.() ?? createEmptyAppPageRenderObservationState()
 	});
+	const skipDisposition = options.skipDisposition ?? createRenderLifecycleSkipDisposition({
+		artifactCompatibility,
+		cleanPathname: options.cleanPathname,
+		clientReuseManifest: options.clientReuseManifest,
+		element: options.element,
+		isRscRequest: options.isRscRequest,
+		layoutFlags,
+		layoutParamAccess: options.layoutParamAccess
+	});
+	const shouldBypassRscCacheForSkipTransport = options.isRscRequest && isSkipTransportEnabled(skipDisposition);
 	const outgoingElement = AppElementsWire.encodeOutgoingPayload({
 		element: options.element,
 		layoutFlags,
 		...artifactCompatibility ? { artifactCompatibility } : {},
-		renderObservation: payloadRenderObservation
+		renderObservation: payloadRenderObservation,
+		skipDisposition: options.isRscRequest ? skipDisposition : void 0
 	});
 	const compileEnd = options.isProduction ? void 0 : performance.now();
 	const rscErrorTracker = createAppPageRscErrorTracker(options.createRscOnErrorHandler(options.cleanPathname, options.routePattern));
 	const rscStream = runWithFetchDedupe(() => options.renderToReadableStream(outgoingElement, { onError: rscErrorTracker.onRenderError }));
 	let revalidateSeconds = options.revalidateSeconds;
 	let expireSeconds = options.expireSeconds;
-	const shouldCaptureRscForCacheMetadata = options.isProgressiveActionRender !== true && (options.isProduction || options.isPrerender === true) && (revalidateSeconds === null || revalidateSeconds > 0 && revalidateSeconds !== Infinity) && !options.isDraftMode && !options.isForceDynamic;
+	const shouldCaptureRscForCacheMetadata = options.isProgressiveActionRender !== true && (options.isProduction || options.isPrerender === true) && (revalidateSeconds === null || revalidateSeconds > 0 && revalidateSeconds !== Infinity) && !options.isDraftMode && !options.isForceDynamic && !shouldBypassRscCacheForSkipTransport;
 	const rscCapture = teeAppPageRscStreamForCapture(rscStream, shouldCaptureRscForCacheMetadata);
 	const rscForResponse = rscCapture.ssrStream;
 	const capturedRscDataRef = { value: null };
@@ -177,7 +333,7 @@ async function renderAppPageLifecycle(options) {
 			}));
 		}
 		const dynamicUsedDuringBuild = options.consumeDynamicUsage();
-		const rscResponsePolicy = resolveAppPageRscResponsePolicy({
+		const rscResponsePolicy = shouldBypassRscCacheForSkipTransport ? { cacheControl: NO_STORE_CACHE_CONTROL } : resolveAppPageRscResponsePolicy({
 			dynamicUsedDuringBuild,
 			isDraftMode: options.isDraftMode,
 			isDynamicError: options.isDynamicError,
@@ -187,7 +343,9 @@ async function renderAppPageLifecycle(options) {
 			expireSeconds,
 			revalidateSeconds
 		});
+		if (shouldBypassRscCacheForSkipTransport) options.isrDebug?.("RSC cache write skipped (skip transport payload)", options.cleanPathname);
 		const rscResponse = buildAppPageRscResponse(rscForResponse, {
+			dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true && !options.isForceStatic && (dynamicUsedDuringBuild || !shouldCaptureRscForCacheMetadata) ? options.dynamicStaleTimeSeconds : void 0,
 			isEdgeRuntime: options.isEdgeRuntime,
 			middlewareContext: options.middlewareContext,
 			mountedSlotsHeader: options.mountedSlotsHeader,
@@ -250,7 +408,7 @@ async function renderAppPageLifecycle(options) {
 			if (!options.isProduction) renderEnd = performance.now();
 		},
 		renderErrorBoundaryResponse(error) {
-			return options.renderErrorBoundaryResponse(error);
+			return options.renderErrorBoundaryResponse(rscErrorTracker.getCapturedError() ?? error);
 		},
 		async renderHtmlStream() {
 			const ssrHandler = await options.loadSsrHandler();
@@ -275,8 +433,9 @@ async function renderAppPageLifecycle(options) {
 		resolveSpecialError: resolveAppPageSpecialError
 	});
 	if (htmlRender.response) return htmlRender.response;
-	const htmlStream = htmlRender.htmlStream;
+	let htmlStream = htmlRender.htmlStream;
 	if (!htmlStream) throw new Error("[vinext] Expected an HTML stream when no fallback response was returned");
+	if (options.isPrerender === true) await htmlRender.metadataReady;
 	if (options.hasLoadingBoundary) {
 		const captured = rscErrorTracker.getCapturedSpecialError();
 		if (captured) {
@@ -295,7 +454,7 @@ async function renderAppPageLifecycle(options) {
 		if (cleanResponse) return cleanResponse;
 	}
 	if (options.isPrerender === true) {
-		await settleCapturedRscRenderForCacheMetadata(capturedRscDataRef.value);
+		await settleCapturedRscRenderForCacheMetadata(htmlRender.capturedRscData);
 		({expireSeconds, revalidateSeconds} = applyRequestCacheLife({
 			expireSeconds,
 			requestCacheLife: readRequestCacheLifeForPrerender(options),
@@ -407,5 +566,3 @@ async function settleCapturedRscRenderForCacheMetadata(capturedRscDataPromise) {
 }
 //#endregion
 export { renderAppPageLifecycle };
-
-//# sourceMappingURL=app-page-render.js.map

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

@@ -1,4 +1,5 @@
 import { AppPageSpecialError } from "./app-page-execution.js";
+import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 
 //#region src/server/app-page-request.d.ts
 type AppPageParams = Record<string, string | string[]>;
@@ -76,13 +77,14 @@ type ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts> = {
 type ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>;
 type ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>;
 type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
-  buildPageElement: (route: TRoute, params: AppPageParams, interceptOpts: TInterceptOpts | undefined, searchParams: URLSearchParams) => Promise<TElement>;
+  buildPageElement: (route: TRoute, params: AppPageParams, interceptOpts: TInterceptOpts | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker) => Promise<TElement>;
   cleanPathname: string;
   currentRoute: TRoute;
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
   getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
   isRscRequest: boolean;
+  layoutParamAccess?: AppLayoutParamAccessTracker;
   renderInterceptResponse: (route: TRoute, element: TElement) => Promise<Response> | Response;
   searchParams: URLSearchParams;
   setNavigationContext: (context: {
@@ -120,5 +122,4 @@ declare function resolveAppPageActionRerenderTarget<TRoute, TPage, TInterceptOpt
 declare function resolveAppPageIntercept<TRoute, TPage, TInterceptOpts, TElement>(options: ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement>): Promise<ResolveAppPageInterceptResult<TInterceptOpts>>;
 declare function buildAppPageElement<TElement>(options: BuildAppPageElementOptions<TElement>): Promise<BuildAppPageElementResult<TElement>>;
 //#endregion
-export { ValidateAppPageDynamicParamsOptions, buildAppPageElement, resolveAppPageActionRerenderTarget, resolveAppPageGenerateStaticParamsSources, resolveAppPageIntercept, resolveAppPageInterceptMatch, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams };
-//# sourceMappingURL=app-page-request.d.ts.map
+export { ValidateAppPageDynamicParamsOptions, buildAppPageElement, resolveAppPageActionRerenderTarget, resolveAppPageGenerateStaticParamsSources, resolveAppPageIntercept, resolveAppPageInterceptMatch, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams };

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

@@ -158,7 +158,7 @@ async function resolveAppPageIntercept(options) {
 			pathname: options.cleanPathname,
 			searchParams: options.searchParams
 		});
-		const interceptElement = await options.buildPageElement(interceptState.sourceRoute, pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)), options.toInterceptOpts(interceptState.intercept), options.searchParams);
+		const interceptElement = await options.buildPageElement(interceptState.sourceRoute, pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)), options.toInterceptOpts(interceptState.intercept), options.searchParams, options.layoutParamAccess);
 		return {
 			interceptOpts: void 0,
 			response: await options.renderInterceptResponse(interceptState.sourceRoute, interceptElement)
@@ -191,5 +191,3 @@ async function buildAppPageElement(options) {
 }
 //#endregion
 export { buildAppPageElement, resolveAppPageActionRerenderTarget, resolveAppPageGenerateStaticParamsSources, resolveAppPageIntercept, resolveAppPageInterceptMatch, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams };
-
-//# sourceMappingURL=app-page-request.js.map

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

@@ -36,6 +36,7 @@ type AppPageHtmlResponsePolicy = {
   shouldWriteToCache: boolean;
 } & AppPageResponsePolicy;
 type BuildAppPageRscResponseOptions = {
+  dynamicStaleTimeSeconds?: number;
   isEdgeRuntime?: boolean;
   middlewareContext: AppPageMiddlewareContext;
   mountedSlotsHeader?: string | null;
@@ -64,5 +65,4 @@ declare function applyEdgeRuntimeHeader(headers: Headers, isEdgeRuntime: boolean
 declare function buildAppPageRscResponse(body: ReadableStream, options: BuildAppPageRscResponseOptions): Response;
 declare function buildAppPageHtmlResponse(body: ReadableStream, options: BuildAppPageHtmlResponseOptions): Response;
 //#endregion
-export { AppPageMiddlewareContext, AppPageResponseTiming, applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, mergeMiddlewareResponseHeaders, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy };
-//# sourceMappingURL=app-page-response.d.ts.map
+export { AppPageMiddlewareContext, AppPageResponseTiming, applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, mergeMiddlewareResponseHeaders, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy };

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

@@ -1,4 +1,4 @@
-import { 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_TIMING_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
@@ -11,6 +11,9 @@ function applyTimingHeader(headers, timing) {
 	const renderMs = timing.responseKind === "html" && timing.renderEnd !== void 0 && timing.compileEnd !== void 0 ? Math.round(timing.renderEnd - timing.compileEnd) : -1;
 	headers.set(VINEXT_TIMING_HEADER, `${handlerStart},${compileMs},${renderMs}`);
 }
+function applyDynamicStaleTimeHeader(headers, dynamicStaleTimeSeconds) {
+	if (dynamicStaleTimeSeconds !== void 0 && Number.isInteger(dynamicStaleTimeSeconds) && dynamicStaleTimeSeconds >= 0) headers.set(VINEXT_DYNAMIC_STALE_TIME_HEADER, String(dynamicStaleTimeSeconds));
+}
 function resolveAppPageRscResponsePolicy(options) {
 	if (options.isDraftMode) return { cacheControl: NO_STORE_CACHE_CONTROL };
 	if (options.isForceDynamic || options.dynamicUsedDuringBuild) return { cacheControl: NO_STORE_CACHE_CONTROL };
@@ -85,6 +88,7 @@ function buildAppPageRscResponse(body, options) {
 	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
 	if (options.params && Object.keys(options.params).length > 0) headers.set(VINEXT_PARAMS_HEADER, encodeURIComponent(JSON.stringify(options.params)));
 	if (options.mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
+	applyDynamicStaleTimeHeader(headers, options.dynamicStaleTimeSeconds);
 	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);
@@ -114,5 +118,3 @@ function buildAppPageHtmlResponse(body, options) {
 }
 //#endregion
 export { applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, mergeMiddlewareResponseHeaders, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy };
-
-//# sourceMappingURL=app-page-response.js.map

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

@@ -1,6 +1,8 @@
 import { AppRouteSemanticIds } from "../routing/app-route-graph.js";
 import { AppElements, AppElementsInterception } from "./app-elements-wire.js";
 import { AppPageParams } from "./app-page-boundary.js";
+import { ThenableParamsObserver } from "../shims/thenable-params.js";
+import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { Metadata, Viewport } from "../shims/metadata.js";
 import { AppPageRenderIdentity } from "./app-page-render-identity.js";
@@ -104,7 +106,8 @@ type AppPageLayoutEntry<TModule extends AppPageModule = AppPageModule, TErrorMod
 type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule> = {
   element: ReactNode;
   globalErrorModule?: TErrorModule | null;
-  makeThenableParams: (params: AppPageParams) => unknown;
+  layoutParamAccess?: AppLayoutParamAccessTracker;
+  makeThenableParams: MakeThenableParams;
   matchedParams: AppPageParams;
   metadataPlacement?: "body" | "head";
   resolvedMetadata: Metadata | null;
@@ -114,8 +117,10 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
   rootNotFoundModule?: TModule | null;
   rootUnauthorizedModule?: TModule | null;
   route: AppPageRouteWiringRoute<TModule, TErrorModule>;
+  searchParams?: unknown;
   slotOverrides?: Readonly<Record<string, AppPageSlotOverride<TModule>>> | null;
 };
+type MakeThenableParams = (params: AppPageParams, observer?: ThenableParamsObserver) => unknown;
 type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule> = BuildAppPageRouteElementOptions<TModule, TErrorModule> & {
   interception?: AppElementsInterception | null;
   interceptionContext?: string | null;
@@ -126,11 +131,17 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
   routePath: string;
 };
 declare function createAppPageTreePath(routeSegments: readonly string[] | null | undefined, treePosition: number): string;
+declare function probeAppPageLayoutWithTracking<TModule extends AppPageModule>(options: {
+  layoutIndex: number;
+  layoutParamAccess: AppLayoutParamAccessTracker | undefined;
+  makeThenableParams: MakeThenableParams;
+  matchedParams: AppPageParams;
+  route: Pick<AppPageRouteWiringRoute<TModule>, "layoutTreePositions" | "layouts" | "routeSegments">;
+}): unknown;
 declare function createAppPageLayoutEntries<TModule extends AppPageModule, TErrorModule extends AppPageErrorModule>(route: Pick<AppPageRouteWiringRoute<TModule, TErrorModule>, "errors" | "errorTreePositions" | "layoutTreePositions" | "layouts" | "notFounds" | "routeSegments"> & {
   forbiddens?: readonly (TModule | null | undefined)[] | null;
   unauthorizeds?: readonly (TModule | null | undefined)[] | null;
 }): AppPageLayoutEntry<TModule, TErrorModule>[];
 declare function buildAppPageElements<TModule extends AppPageModule, TErrorModule extends AppPageErrorModule>(options: BuildAppPageElementsOptions<TModule, TErrorModule>): AppElements;
 //#endregion
-export { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute, AppPageSlotOverride, buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, resolveAppPageChildSegments };
-//# sourceMappingURL=app-page-route-wiring.d.ts.map
+export { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute, AppPageSlotOverride, buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };

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

@@ -1,3 +1,4 @@
+import { createAppRenderDependency, registerAppElementRenderDependencies, renderAfterAppDependencies, renderWithAppDependencyBarrier } from "./app-render-dependency.js";
 import { APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
 import { APP_PREFETCH_LOADING_SHELL_MARKER_KEY } from "./app-elements.js";
@@ -6,12 +7,13 @@ import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead, renderMetadataToHtml } from "../shims/metadata.js";
 import { Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
-import { createAppRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier } from "./app-render-dependency.js";
-import { resolveAppPageSegmentParams } from "./app-page-params.js";
+import { resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { probeReactServerSubtree } from "./app-page-probe.js";
 import { resolveAppPageChildSegments, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey } from "./app-page-segment-state.js";
-import { Suspense } from "react";
+import { Fragment, Suspense } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/server/app-page-route-wiring.tsx
+const APP_PAGE_LAYOUT_PROBE_CHILD = /* @__PURE__ */ jsx(Fragment, {});
 function getDefaultExport(module) {
 	return module?.default ?? null;
 }
@@ -23,6 +25,38 @@ function createAppPageTreePath(routeSegments, treePosition) {
 	if (treePathSegments.length === 0) return "/";
 	return `/${treePathSegments.join("/")}`;
 }
+function readFiniteRevalidateSeconds(module) {
+	const revalidate = module?.revalidate;
+	return typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0 ? revalidate : null;
+}
+function recordLayoutSkipObservationScope(options) {
+	options.layoutParamAccess?.recordLayoutParamScope(options.layoutId, resolveAppPageSegmentParamScopeKeys(options.routeSegments, options.treePosition));
+	const revalidateSeconds = readFiniteRevalidateSeconds(options.layoutModule);
+	if (revalidateSeconds !== null) options.layoutParamAccess?.recordLayoutFiniteRevalidate(options.layoutId, revalidateSeconds);
+}
+function probeAppPageLayoutWithTracking(options) {
+	const treePosition = options.route.layoutTreePositions?.[options.layoutIndex] ?? 0;
+	const treePath = createAppPageTreePath(options.route.routeSegments, treePosition);
+	const layoutId = AppElementsWire.encodeLayoutId(treePath);
+	const probe = () => {
+		const layoutModule = options.route.layouts[options.layoutIndex];
+		const LayoutComponent = getDefaultExport(layoutModule);
+		if (!LayoutComponent) return null;
+		recordLayoutSkipObservationScope({
+			layoutId,
+			layoutModule,
+			layoutParamAccess: options.layoutParamAccess,
+			routeSegments: options.route.routeSegments,
+			treePosition
+		});
+		const layoutParams = resolveAppPageSegmentParams(options.route.routeSegments, treePosition, options.matchedParams);
+		return probeReactServerSubtree(/* @__PURE__ */ jsx(LayoutComponent, {
+			params: options.makeThenableParams(layoutParams, options.layoutParamAccess?.createThenableParamsObserver(layoutId)),
+			children: APP_PAGE_LAYOUT_PROBE_CHILD
+		}));
+	};
+	return options.layoutParamAccess ? options.layoutParamAccess.runLayoutProbe(layoutId, probe) : probe();
+}
 function createAppPageLayoutEntries(route) {
 	return route.layouts.map((layoutModule, index) => {
 		const treePosition = route.layoutTreePositions?.[index] ?? 0;
@@ -87,16 +121,20 @@ function resolveAppPageSlotBindingState(slot, override) {
 	if (getDefaultExport(slot.default)) return "default";
 	return "unmatched";
 }
-function createAppPageSlotBindings(route, layoutEntries, resolveSlotOverride) {
+function createAppPageSlotBindings(route, layoutEntries, resolveSlotOverride, options) {
 	const bindings = [];
 	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
 		const layoutEntry = layoutEntries[slot.layoutIndex >= 0 ? slot.layoutIndex : layoutEntries.length - 1] ?? null;
 		const ownerLayoutId = layoutEntry?.id ?? null;
 		const override = resolveSlotOverride(slotKey, slot.name);
+		const slotId = resolveAppPageSlotId(slot, layoutEntry?.treePath ?? "/");
+		const state = resolveAppPageSlotBindingState(slot, override);
+		const activeRouteId = state === "active" ? options.interception?.slotId === slotId ? options.interception.targetRouteId : AppElementsWire.encodeRouteId(options.routePath, null) : null;
 		bindings.push({
+			...activeRouteId !== null ? { activeRouteId } : {},
 			ownerLayoutId,
-			slotId: resolveAppPageSlotId(slot, layoutEntry?.treePath ?? "/"),
-			state: resolveAppPageSlotBindingState(slot, override)
+			slotId,
+			state
 		});
 	}
 	return normalizeAppElementsSlotBindings(bindings, { layoutIds: layoutEntries.map((entry) => entry.id) });
@@ -139,6 +177,7 @@ function buildAppPageElements(options) {
 	const layoutIndicesByTreePosition = /* @__PURE__ */ new Map();
 	for (let index = 0; index < layoutEntries.length; index++) layoutIndicesByTreePosition.set(layoutEntries[index].treePosition, index);
 	const layoutDependenciesByIndex = /* @__PURE__ */ new Map();
+	const renderDependenciesByElementId = /* @__PURE__ */ new Map();
 	const layoutDependenciesBefore = [];
 	const slotDependenciesByLayoutIndex = [];
 	const templateDependenciesById = /* @__PURE__ */ new Map();
@@ -166,7 +205,11 @@ function buildAppPageElements(options) {
 		layoutIds: options.route.ids?.layouts ?? layoutEntries.map((entry) => entry.id),
 		rootLayoutTreePath,
 		routeId,
-		slotBindings: createAppPageSlotBindings(options.route, layoutEntries, resolveSlotOverride)
+		slotBindings: createAppPageSlotBindings(options.route, layoutEntries, resolveSlotOverride, {
+			interception: renderIdentity?.interception ?? options.interception ?? null,
+			interceptionContext,
+			routePath: options.routePath
+		})
 	}) };
 	if (options.route.staticSiblings && options.route.staticSiblings.length > 0) elements[APP_STATIC_SIBLINGS_KEY] = options.route.staticSiblings;
 	const getEffectiveSlotParams = (slotKey, slotName) => resolveSlotOverride(slotKey, slotName)?.params ?? options.matchedParams;
@@ -178,6 +221,7 @@ function buildAppPageElements(options) {
 			if (getDefaultExport(layoutEntry.layoutModule)) {
 				const layoutDependency = createAppRenderDependency();
 				layoutDependenciesByIndex.set(layoutIndex, layoutDependency);
+				renderDependenciesByElementId.set(layoutEntry.id, layoutDependency);
 				pageDependencies.push(layoutDependency);
 			}
 			slotDependenciesByLayoutIndex[layoutIndex] = [...pageDependencies];
@@ -211,7 +255,15 @@ function buildAppPageElements(options) {
 		const layoutEntry = layoutEntries[index];
 		const layoutComponent = getDefaultExport(layoutEntry.layoutModule);
 		if (!layoutComponent) continue;
-		const layoutProps = { params: options.makeThenableParams(resolveAppPageSegmentParams(options.route.routeSegments, layoutEntry.treePosition, options.matchedParams)) };
+		const layoutParams = resolveAppPageSegmentParams(options.route.routeSegments, layoutEntry.treePosition, options.matchedParams);
+		recordLayoutSkipObservationScope({
+			layoutId: layoutEntry.id,
+			layoutModule: layoutEntry.layoutModule,
+			layoutParamAccess: options.layoutParamAccess,
+			routeSegments: options.route.routeSegments,
+			treePosition: layoutEntry.treePosition
+		});
+		const layoutProps = { params: options.makeThenableParams(layoutParams, options.layoutParamAccess?.createThenableParamsObserver(layoutEntry.id)) };
 		for (const slot of Object.values(options.route.slots ?? {})) {
 			const slotName = slot.name;
 			if ((slot.layoutIndex >= 0 ? slot.layoutIndex : layoutEntries.length - 1) !== index) continue;
@@ -245,6 +297,7 @@ function buildAppPageElements(options) {
 		}
 		const slotThenableParams = options.makeThenableParams(slotParams);
 		const slotProps = { params: slotThenableParams };
+		if (options.searchParams !== void 0) slotProps.searchParams = options.searchParams;
 		if (slotOverride?.props) Object.assign(slotProps, slotOverride.props);
 		let slotElement = /* @__PURE__ */ jsx(slotComponent, { ...slotProps });
 		const interceptLayouts = slotOverride?.layoutModules ?? [];
@@ -381,9 +434,8 @@ function buildAppPageElements(options) {
 		routeChildren,
 		createAppPageRouteBodyMetadata(options.resolvedMetadata, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement)
 	] });
+	registerAppElementRenderDependencies(elements, renderDependenciesByElementId);
 	return elements;
 }
 //#endregion
-export { buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, resolveAppPageChildSegments };
-
-//# sourceMappingURL=app-page-route-wiring.js.map
+export { buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };

package/dist/server/app-page-search-params-observation.d.ts

@@ -0,0 +1,10 @@
+import { ThenableParams } from "../shims/thenable-params.js";
+import { AppPageSearchParams } from "./app-page-head.js";
+
+//#region src/server/app-page-search-params-observation.d.ts
+type AppPageSearchParamsObservationOptions = {
+  observeReactPromiseStatus?: boolean;
+};
+declare function makeObservedAppPageSearchParamsThenable(pageSearchParams: AppPageSearchParams, options?: AppPageSearchParamsObservationOptions): ThenableParams<AppPageSearchParams>;
+//#endregion
+export { makeObservedAppPageSearchParamsThenable };

package/dist/server/app-page-search-params-observation.js

@@ -0,0 +1,20 @@
+import { markDynamicUsage, markRenderRequestApiUsage, throwIfInsideCacheScope } from "../shims/headers.js";
+import { makeThenableParams } from "../shims/thenable-params.js";
+//#region src/server/app-page-search-params-observation.ts
+function markAppPageSearchParamsAccess() {
+	throwIfInsideCacheScope("searchParams");
+	markDynamicUsage();
+	markRenderRequestApiUsage("searchParams");
+}
+function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {}) {
+	const observer = { observeParamAccess() {
+		markAppPageSearchParamsAccess();
+	} };
+	if (options.observeReactPromiseStatus === true) return makeThenableParams(pageSearchParams, {
+		...observer,
+		observeReactPromiseStatus: true
+	});
+	return makeThenableParams(pageSearchParams, observer);
+}
+//#endregion
+export { makeObservedAppPageSearchParamsThenable };

package/dist/server/app-page-segment-state.d.ts

@@ -6,5 +6,4 @@ declare function resolveAppPageSegmentStateKey(routeSegments: readonly string[],
 declare function resolveAppPageRouteStateKey(routeSegments: readonly string[], params: AppPageParams): string;
 declare function resolveAppPageLeafSegmentStateKey(routeSegments: readonly string[], params: AppPageParams): string;
 //#endregion
-export { resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };
-//# sourceMappingURL=app-page-segment-state.d.ts.map
+export { resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };

package/dist/server/app-page-segment-state.js

@@ -1,10 +1,5 @@
+import { isCatchAllSegment, isOptionalCatchAllSegment } from "../routing/utils.js";
 //#region src/server/app-page-segment-state.ts
-function isOptionalCatchAllSegment(segment) {
-	return segment.startsWith("[[...") && segment.endsWith("]]") && segment.length > 7;
-}
-function isCatchAllSegment(segment) {
-	return segment.startsWith("[...") && segment.endsWith("]") && segment.length > 5;
-}
 function isDynamicSegment(segment) {
 	return segment.startsWith("[") && segment.endsWith("]") && !segment.includes(".");
 }
@@ -83,5 +78,3 @@ function resolveAppPageLeafSegmentStateKey(routeSegments, params) {
 }
 //#endregion
 export { resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };
-
-//# sourceMappingURL=app-page-segment-state.js.map