vinext 0.0.54 → 0.1.0

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

@@ -9,10 +9,12 @@ import { tagAppPageMetadataError } from "./app-page-execution.js";
 * `APP_PAGE_METADATA_ERROR_MARKER` symbol. The marker lets downstream special-
 * error handling distinguish a `generateMetadata()` redirect/notFound from a
 * page-component redirect/notFound, which matters because metadata is
-* suspended/streamed in Next.js: its redirects ride inside the flight payload
-* with a 200 status code even for document SSR, whereas page redirects still
-* emit a 307 for SSR. See https://github.com/cloudflare/vinext/issues/1347
-* and Next.js test/e2e/app-dir/metadata-navigation.
+* suspended/streamed in Next.js. Its redirects no longer become a plain
+* HTTP 307: RSC navigation rides inside the flight payload (200), streaming
+* document SSR gets an HTML refresh meta tag (200), and html-limited bots
+* get a blocking 307 — whereas page redirects still emit a 307 for SSR.
+* See https://github.com/cloudflare/vinext/issues/1347
+* and Next.js test/e2e/app-dir/metadata-streaming.
 */
 async function resolveModuleMetadata(...args) {
 	try {
@@ -225,5 +227,3 @@ async function resolveAppPageHeadInner(options) {
 }
 //#endregion
 export { collectAppPageSearchParams, resolveActiveParallelRouteHeadInputs, resolveAppPageHead };
-
-//# sourceMappingURL=app-page-head.js.map

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

@@ -12,5 +12,4 @@ type ResolveAppPageMethodResponseOptions = {
 declare function isStaticOrSsgAppPageCandidate(options: AppPageMethodPolicyOptions): boolean;
 declare function resolveAppPageMethodResponse(options: ResolveAppPageMethodResponseOptions): Response | null;
 //#endregion
-export { isStaticOrSsgAppPageCandidate, resolveAppPageMethodResponse };
-//# sourceMappingURL=app-page-method.d.ts.map
+export { isStaticOrSsgAppPageCandidate, resolveAppPageMethodResponse };

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

@@ -23,5 +23,3 @@ function resolveAppPageMethodResponse(options) {
 }
 //#endregion
 export { isStaticOrSsgAppPageCandidate, resolveAppPageMethodResponse };
-
-//# sourceMappingURL=app-page-method.js.map

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

@@ -2,7 +2,7 @@ import { AppPageParams } from "./app-page-boundary.js";
 
 //#region src/server/app-page-params.d.ts
 declare function getAppPageSegmentParamName(segment: string): string | null;
+declare function resolveAppPageSegmentParamScopeKeys(routeSegments: readonly string[] | null | undefined, treePosition: number): readonly string[];
 declare function resolveAppPageSegmentParams(routeSegments: readonly string[] | null | undefined, treePosition: number, matchedParams: AppPageParams): AppPageParams;
 //#endregion
-export { getAppPageSegmentParamName, resolveAppPageSegmentParams };
-//# sourceMappingURL=app-page-params.d.ts.map
+export { getAppPageSegmentParamName, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams };

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

@@ -8,6 +8,19 @@ function getAppPageSegmentParamName(segment) {
 function isEmptyOptionalCatchAll(segment, paramValue) {
 	return segment.startsWith("[[...") && Array.isArray(paramValue) && paramValue.length === 0;
 }
+function resolveAppPageSegmentParamScopeKeys(routeSegments, treePosition) {
+	const paramNames = [];
+	const seen = /* @__PURE__ */ new Set();
+	const segments = routeSegments ?? [];
+	const end = Math.min(Math.max(treePosition, 0), segments.length);
+	for (let index = 0; index < end; index++) {
+		const paramName = getAppPageSegmentParamName(segments[index]);
+		if (!paramName || seen.has(paramName)) continue;
+		seen.add(paramName);
+		paramNames.push(paramName);
+	}
+	return paramNames;
+}
 function resolveAppPageSegmentParams(routeSegments, treePosition, matchedParams) {
 	const segmentParams = {};
 	const segments = routeSegments ?? [];
@@ -23,6 +36,4 @@ function resolveAppPageSegmentParams(routeSegments, treePosition, matchedParams)
 	return segmentParams;
 }
 //#endregion
-export { getAppPageSegmentParamName, resolveAppPageSegmentParams };
-
-//# sourceMappingURL=app-page-params.js.map
+export { getAppPageSegmentParamName, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams };

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

@@ -2,6 +2,17 @@ import { LayoutFlags } from "./app-elements-wire.js";
 import { AppPageSpecialError, LayoutClassificationOptions } from "./app-page-execution.js";
 
 //#region src/server/app-page-probe.d.ts
+type ProbeReactServerSubtreeOptions = Readonly<{
+  maxDepth?: number;
+  maxNodes?: number;
+}>;
+/**
+ * Invokes server-component children returned by a layout probe so per-layout
+ * skip eligibility observes data dependencies created below the layout's
+ * immediate function body. The real RSC render remains authoritative; probe
+ * failures only make static-layout skip fall back to render-and-send.
+ */
+declare function probeReactServerSubtree(node: unknown, options?: ProbeReactServerSubtreeOptions): Promise<void>;
 /**
  * Build a probePage() invocation for the App Router request lifecycle.
  *
@@ -24,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;
@@ -41,5 +130,4 @@ type ProbeAppPageBeforeRenderOptions = {
 };
 declare function probeAppPageBeforeRender(options: ProbeAppPageBeforeRenderOptions): Promise<ProbeAppPageBeforeRenderResult>;
 //#endregion
-export { probeAppPage, probeAppPageBeforeRender };
-//# sourceMappingURL=app-page-probe.d.ts.map
+export { buildAppPageProbes, probeAppPage, probeAppPageBeforeRender, probeReactServerSubtree };

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

@@ -1,7 +1,130 @@
-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;
+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");
+var AppPageSubtreeProbeLimitError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AppPageSubtreeProbeLimitError";
+	}
+};
+var AppPageSubtreeProbeUnsupportedIterableError = class extends Error {
+	constructor() {
+		super("App page layout subtree probe cannot safely inspect iterable children");
+		this.name = "AppPageSubtreeProbeUnsupportedIterableError";
+	}
+};
+function isIterable(value) {
+	return Boolean(value && typeof value !== "string" && typeof value === "object" && Symbol.iterator in value && typeof value[Symbol.iterator] === "function");
+}
+function isProbeReactElement(value) {
+	return isValidElement(value);
+}
+function isObjectLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+function isUnknownFunction(value) {
+	return typeof value === "function";
+}
+function readReactMemoType(value) {
+	if (!isObjectLike(value) || Reflect.get(value, "$$typeof") !== REACT_MEMO_TYPE) return null;
+	return { innerType: Reflect.get(value, "type") };
+}
+function readReactLazyType(value) {
+	if (!isObjectLike(value) || Reflect.get(value, "$$typeof") !== REACT_LAZY_TYPE) return null;
+	const init = Reflect.get(value, "_init");
+	if (!isUnknownFunction(init)) return null;
+	return {
+		init,
+		payload: Reflect.get(value, "_payload")
+	};
+}
+function readReactForwardRefRender(value) {
+	if (!isObjectLike(value) || Reflect.get(value, "$$typeof") !== REACT_FORWARD_REF_TYPE) return null;
+	const render = Reflect.get(value, "render");
+	return isUnknownFunction(render) ? render : null;
+}
+async function resolveReactLazyType(lazyType) {
+	try {
+		return lazyType.init(lazyType.payload);
+	} catch (error) {
+		if (!isPromiseLike(error)) throw error;
+		await error;
+		return lazyType.init(lazyType.payload);
+	}
+}
+/**
+* Invokes server-component children returned by a layout probe so per-layout
+* skip eligibility observes data dependencies created below the layout's
+* immediate function body. The real RSC render remains authoritative; probe
+* failures only make static-layout skip fall back to render-and-send.
+*/
+async function probeReactServerSubtree(node, options = {}) {
+	const maxDepth = options.maxDepth ?? DEFAULT_SUBTREE_PROBE_MAX_DEPTH;
+	const maxNodes = options.maxNodes ?? DEFAULT_SUBTREE_PROBE_MAX_NODES;
+	let visitedNodes = 0;
+	const enterProbeNode = (depth) => {
+		if (depth > maxDepth) throw new AppPageSubtreeProbeLimitError("App page layout subtree probe exceeded max depth");
+		visitedNodes += 1;
+		if (visitedNodes > maxNodes) throw new AppPageSubtreeProbeLimitError("App page layout subtree probe exceeded max nodes");
+	};
+	const renderElementType = async (type, props, depth, wrapperDepth = 0) => {
+		if (wrapperDepth > maxDepth) throw new AppPageSubtreeProbeLimitError("App page layout subtree probe exceeded max depth");
+		if (isUnknownFunction(type)) {
+			await visit(type(props), depth + 1);
+			return true;
+		}
+		const memoType = readReactMemoType(type);
+		if (memoType) return renderElementType(memoType.innerType, props, depth, wrapperDepth + 1);
+		const lazyType = readReactLazyType(type);
+		if (lazyType) return renderElementType(await resolveReactLazyType(lazyType), props, depth, wrapperDepth + 1);
+		const forwardRefRender = readReactForwardRefRender(type);
+		if (forwardRefRender) {
+			await visit(forwardRefRender(props, null), depth + 1);
+			return true;
+		}
+		return false;
+	};
+	const visit = async (value, depth) => {
+		enterProbeNode(depth);
+		if (value == null || typeof value === "boolean" || typeof value === "number") return;
+		if (typeof value === "string" || typeof value === "bigint") return;
+		if (isPromiseLike(value)) {
+			await visit(await value, depth);
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const child of value) await visit(child, depth + 1);
+			return;
+		}
+		if (isIterable(value) && !isProbeReactElement(value)) throw new AppPageSubtreeProbeUnsupportedIterableError();
+		if (!isProbeReactElement(value)) return;
+		if (value.type === Fragment || typeof value.type === "string") {
+			await visit(value.props.children, depth + 1);
+			return;
+		}
+		if (await renderElementType(value.type, value.props, depth)) return;
+		await visit(value.props.children, depth + 1);
+	};
+	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.
 *
@@ -23,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 = {};
@@ -71,6 +268,4 @@ async function probeAppPageBeforeRender(options) {
 	};
 }
 //#endregion
-export { probeAppPage, probeAppPageBeforeRender };
-
-//# 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 };