vinext 0.0.55 → 0.1.0

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

@@ -35,6 +35,84 @@ declare function probeAppPage(options: {
   asyncRouteParams: unknown;
   searchParams: URLSearchParams | null | undefined;
 }): unknown;
+type AppPageProbeModule = Readonly<{
+  default?: unknown;
+}> | null | undefined;
+type AppPageProbeSlot = Readonly<{
+  page?: AppPageProbeModule;
+}> | null | undefined;
+type AppPageProbeRoute = Readonly<{
+  slots?: Readonly<Record<string, AppPageProbeSlot>> | null;
+}>;
+type AppPageProbeIntercept = Readonly<{
+  page?: AppPageProbeModule;
+  matchedParams?: unknown;
+  /**
+   * Key of the parallel-route slot this interception overrides. At render
+   * time the matched route's `slots[slotKey].page` is replaced by the
+   * interception page (see app-page-element-builder.ts), so the slot's own
+   * page never renders for this request.
+   */
+  slotKey?: string | null;
+}> | null | undefined;
+/**
+ * Fan out the per-request page probes for the App Router dispatch lifecycle.
+ *
+ * A single request can render more than one page component: the matched page,
+ * each active parallel-route slot page, and an interception page when one
+ * matches. Each must be probed so searchParams access anywhere in the rendered
+ * tree bails the request out of the query-invariant static cache.
+ *
+ * Extracted out of the generated RSC entry so the fan-out is directly
+ * unit-testable and the entry stays codegen glue (see AGENTS.md "Generated
+ * Entry Modules Should Stay Thin"). Returns a list of resolved promises so the
+ * caller can `Promise.all` them.
+ *
+ * The fan-out is scoped to the page components that render for this request:
+ *
+ * - **Interception override:** when an interception matches it replaces the
+ *   page of the slot named by `intercept.slotKey` (the element builder sets
+ *   `overrides[slotKey].pageModule` to the interception page, which wins over
+ *   `slot.page` in `app-page-route-wiring.tsx`). We probe the interception page
+ *   in place of that slot's own page rather than probing both — probing the
+ *   overridden slot page would mark an otherwise-static request dynamic for a
+ *   component that never renders.
+ * - **Non-overridden slots:** `slot.page?.default` is exactly what renders.
+ *   `app-page-route-wiring.tsx` resolves a slot to `overrideOrPageComponent ??
+ *   defaultComponent`, so whenever a slot has a `page.tsx` that page renders.
+ *   When a slot has only a `default.tsx` (including the soft-nav case at
+ *   `app-page-route-wiring.tsx:741` that skips an already-mounted slot), there
+ *   is no `slot.page?.default`, so `probeAppPage` short-circuits to `null` and
+ *   probes nothing — a no-op, not an over-bail.
+ *
+ * Interception only fires for RSC navigations (`resolveAppPageInterceptState`
+ * returns `kind: "none"` when `!isRscRequest`, app-page-request.ts:324), so the
+ * interception handling here is gated on `isRscRequest`. For non-RSC (HTML)
+ * requests the matched route renders normally, so we probe every slot's own
+ * page and skip the interception probe entirely. The remaining "source-route"
+ * interception case (where a *different* route renders, app-page-request.ts:342)
+ * never reaches this probe: `dispatchAppPage` returns the intercepted response
+ * before calling `probePage`, so by the time this runs any matched interception
+ * is the current-route override case above.
+ *
+ * A `default.tsx` that itself awaits `searchParams` is not probed here, but the
+ * real render still observes that access and skips the query-invariant cache
+ * write (the same loading.tsx backstop), so this cannot under-bail.
+ */
+declare function buildAppPageProbes(options: {
+  route: AppPageProbeRoute;
+  pageComponent: unknown;
+  asyncRouteParams: unknown;
+  searchParams: URLSearchParams | null | undefined;
+  intercept?: AppPageProbeIntercept;
+  /**
+   * Whether this is an RSC navigation. Interception only fires for RSC
+   * requests, so the interception probe is ignored when this is false.
+   */
+  isRscRequest: boolean; /** Fallback raw params used when an interception match omits its own. */
+  matchedParams: unknown;
+  makeThenableParams: (params: unknown) => unknown;
+}): Promise<unknown>[];
 type ProbeAppPageBeforeRenderResult = {
   response: Response | null;
   layoutFlags: LayoutFlags;
@@ -52,5 +130,4 @@ type ProbeAppPageBeforeRenderOptions = {
 };
 declare function probeAppPageBeforeRender(options: ProbeAppPageBeforeRenderOptions): Promise<ProbeAppPageBeforeRenderResult>;
 //#endregion
-export { probeAppPage, probeAppPageBeforeRender, probeReactServerSubtree };
-//# sourceMappingURL=app-page-probe.d.ts.map
+export { buildAppPageProbes, probeAppPage, probeAppPageBeforeRender, probeReactServerSubtree };

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

@@ -1,6 +1,9 @@
-import { makeThenableParams } from "../shims/thenable-params.js";
+import { markAppPagePropsForUseCache } from "../shims/cache-runtime.js";
+import { isNextRouterError } from "../shims/navigation.js";
+import { isPromiseLike } from "../utils/promise.js";
 import { probeAppPageComponent, probeAppPageLayouts } from "./app-page-execution.js";
 import { collectAppPageSearchParams } from "./app-page-head.js";
+import { makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
 import { Fragment, isValidElement } from "react";
 //#region src/server/app-page-probe.ts
 const DEFAULT_SUBTREE_PROBE_MAX_DEPTH = 32;
@@ -20,9 +23,6 @@ var AppPageSubtreeProbeUnsupportedIterableError = class extends Error {
 		this.name = "AppPageSubtreeProbeUnsupportedIterableError";
 	}
 };
-function isPromiseLike(value) {
-	return Boolean(value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function");
-}
 function isIterable(value) {
 	return Boolean(value && typeof value !== "string" && typeof value === "object" && Symbol.iterator in value && typeof value[Symbol.iterator] === "function");
 }
@@ -117,6 +117,14 @@ async function probeReactServerSubtree(node, options = {}) {
 	};
 	await visit(node, 0);
 }
+async function probeReactServerSubtreeForDynamicUsage(node) {
+	try {
+		await probeReactServerSubtree(node);
+	} catch (error) {
+		if (isNextRouterError(error)) return;
+		throw error;
+	}
+}
 /**
 * Build a probePage() invocation for the App Router request lifecycle.
 *
@@ -138,10 +146,84 @@ function probeAppPage(options) {
 	const { pageComponent, asyncRouteParams, searchParams } = options;
 	if (typeof pageComponent !== "function") return null;
 	const { pageSearchParams } = collectAppPageSearchParams(searchParams);
-	return pageComponent({
+	const result = pageComponent(markAppPagePropsForUseCache({
 		params: asyncRouteParams,
-		searchParams: makeThenableParams(pageSearchParams)
+		searchParams: makeObservedAppPageSearchParamsThenable(pageSearchParams, { observeReactPromiseStatus: true })
+	}));
+	if (isPromiseLike(result)) return result.then(async (resolved) => {
+		await probeReactServerSubtreeForDynamicUsage(resolved);
+		return resolved;
 	});
+	if (isValidElement(result) || Array.isArray(result)) return probeReactServerSubtreeForDynamicUsage(result).then(() => result);
+	return result;
+}
+/**
+* Fan out the per-request page probes for the App Router dispatch lifecycle.
+*
+* A single request can render more than one page component: the matched page,
+* each active parallel-route slot page, and an interception page when one
+* matches. Each must be probed so searchParams access anywhere in the rendered
+* tree bails the request out of the query-invariant static cache.
+*
+* Extracted out of the generated RSC entry so the fan-out is directly
+* unit-testable and the entry stays codegen glue (see AGENTS.md "Generated
+* Entry Modules Should Stay Thin"). Returns a list of resolved promises so the
+* caller can `Promise.all` them.
+*
+* The fan-out is scoped to the page components that render for this request:
+*
+* - **Interception override:** when an interception matches it replaces the
+*   page of the slot named by `intercept.slotKey` (the element builder sets
+*   `overrides[slotKey].pageModule` to the interception page, which wins over
+*   `slot.page` in `app-page-route-wiring.tsx`). We probe the interception page
+*   in place of that slot's own page rather than probing both — probing the
+*   overridden slot page would mark an otherwise-static request dynamic for a
+*   component that never renders.
+* - **Non-overridden slots:** `slot.page?.default` is exactly what renders.
+*   `app-page-route-wiring.tsx` resolves a slot to `overrideOrPageComponent ??
+*   defaultComponent`, so whenever a slot has a `page.tsx` that page renders.
+*   When a slot has only a `default.tsx` (including the soft-nav case at
+*   `app-page-route-wiring.tsx:741` that skips an already-mounted slot), there
+*   is no `slot.page?.default`, so `probeAppPage` short-circuits to `null` and
+*   probes nothing — a no-op, not an over-bail.
+*
+* Interception only fires for RSC navigations (`resolveAppPageInterceptState`
+* returns `kind: "none"` when `!isRscRequest`, app-page-request.ts:324), so the
+* interception handling here is gated on `isRscRequest`. For non-RSC (HTML)
+* requests the matched route renders normally, so we probe every slot's own
+* page and skip the interception probe entirely. The remaining "source-route"
+* interception case (where a *different* route renders, app-page-request.ts:342)
+* never reaches this probe: `dispatchAppPage` returns the intercepted response
+* before calling `probePage`, so by the time this runs any matched interception
+* is the current-route override case above.
+*
+* A `default.tsx` that itself awaits `searchParams` is not probed here, but the
+* real render still observes that access and skips the query-invariant cache
+* write (the same loading.tsx backstop), so this cannot under-bail.
+*/
+function buildAppPageProbes(options) {
+	const { route, pageComponent, asyncRouteParams, searchParams, matchedParams } = options;
+	const intercept = options.isRscRequest ? options.intercept : null;
+	const probes = [probeAppPage({
+		pageComponent,
+		asyncRouteParams,
+		searchParams
+	})];
+	const overriddenSlotKey = intercept?.slotKey ?? null;
+	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
+		if (overriddenSlotKey !== null && slotKey === overriddenSlotKey) continue;
+		probes.push(probeAppPage({
+			pageComponent: slot?.page?.default,
+			asyncRouteParams,
+			searchParams
+		}));
+	}
+	if (intercept) probes.push(probeAppPage({
+		pageComponent: intercept.page?.default,
+		asyncRouteParams: options.makeThenableParams(intercept.matchedParams ?? matchedParams),
+		searchParams
+	}));
+	return probes.map((probe) => Promise.resolve(probe));
 }
 async function probeAppPageBeforeRender(options) {
 	let layoutFlags = {};
@@ -186,6 +268,4 @@ async function probeAppPageBeforeRender(options) {
 	};
 }
 //#endregion
-export { probeAppPage, probeAppPageBeforeRender, probeReactServerSubtree };
-
-//# sourceMappingURL=app-page-probe.js.map
+export { buildAppPageProbes, probeAppPage, probeAppPageBeforeRender, probeReactServerSubtree };

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

@@ -18,5 +18,4 @@ type AppPageRenderIdentity = {
 declare function normalizeAppPageInterceptionProofPathname(pathname: string | null): string | null;
 declare function createAppPageRenderIdentity(input: AppPageRenderIdentityInput): AppPageRenderIdentity;
 //#endregion
-export { AppPageRenderIdentity, createAppPageRenderIdentity, normalizeAppPageInterceptionProofPathname };
-//# sourceMappingURL=app-page-render-identity.d.ts.map
+export { AppPageRenderIdentity, createAppPageRenderIdentity, normalizeAppPageInterceptionProofPathname };

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

@@ -38,5 +38,3 @@ function createAppPageRenderIdentity(input) {
 }
 //#endregion
 export { createAppPageRenderIdentity, normalizeAppPageInterceptionProofPathname };
-
-//# sourceMappingURL=app-page-render-identity.js.map

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

@@ -31,5 +31,4 @@ declare function createAppPageHtmlOutputScope(options: {
   routePattern: string;
 }): CacheProofOutputScope;
 //#endregion
-export { AppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState };
-//# sourceMappingURL=app-page-render-observation.d.ts.map
+export { AppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState };

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

@@ -64,5 +64,3 @@ function createAppPageHtmlOutputScope(options) {
 }
 //#endregion
 export { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState };
-
-//# sourceMappingURL=app-page-render-observation.js.map

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

@@ -1,9 +1,12 @@
 import { CachedAppPageValue } from "../shims/cache.js";
+import { ClientReuseManifestParseResult, ClientReuseManifestSkipDisposition } from "./client-reuse-manifest.js";
 import { AppOutgoingElements } from "./app-elements-wire.js";
+import { NavigationContext } from "../shims/navigation.js";
 import { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
+import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageRenderObservationState } from "./app-page-render-observation.js";
 import { ReactNode } from "react";
@@ -34,13 +37,14 @@ type RenderAppPageLifecycleOptions = {
   getFontLinks: () => string[];
   getFontPreloads: () => AppPageFontPreload[];
   getFontStyles: () => string[];
-  getNavigationContext: () => unknown;
+  getNavigationContext: () => NavigationContext | null;
   getPageTags: () => string[];
   getRequestCacheLife: () => AppPageRequestCacheLife | null;
   peekRequestCacheLife?: () => AppPageRequestCacheLife | null;
   getDraftModeCookieHeader: () => string | null | undefined;
   handlerStart: number;
   hasLoadingBoundary: boolean;
+  dynamicStaleTimeSeconds?: number;
   isDynamicError: boolean;
   isDraftMode: boolean;
   isEdgeRuntime?: boolean;
@@ -76,13 +80,15 @@ type RenderAppPageLifecycleOptions = {
   routePattern: string;
   runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
   scriptNonce?: string;
+  clientReuseManifest?: ClientReuseManifestParseResult;
+  skipDisposition?: ClientReuseManifestSkipDisposition;
   mountedSlotsHeader?: string | null;
   renderMode?: AppRscRenderMode;
   waitUntil?: (promise: Promise<void>) => void;
+  layoutParamAccess?: AppLayoutParamAccessTracker;
   element: ReactNode | Readonly<Record<string, ReactNode>>;
   classification?: LayoutClassificationOptions | null;
 };
 declare function renderAppPageLifecycle(options: RenderAppPageLifecycleOptions): Promise<Response>;
 //#endregion
-export { renderAppPageLifecycle };
-//# sourceMappingURL=app-page-render.d.ts.map
+export { renderAppPageLifecycle };

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