@qzsy/vinext 0.1.7

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

@@ -0,0 +1,39 @@
+//#region src/server/app-page-params.ts
+function getAppPageSegmentParamName(segment) {
+	if (segment.startsWith("[[...") && segment.endsWith("]]") && segment.length > 7) return segment.slice(5, -2);
+	if (segment.startsWith("[...") && segment.endsWith("]") && segment.length > 5) return segment.slice(4, -1);
+	if (segment.startsWith("[") && segment.endsWith("]") && !segment.includes(".") && segment.length > 2) return segment.slice(1, -1);
+	return null;
+}
+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 ?? [];
+	const end = Math.min(Math.max(treePosition, 0), segments.length);
+	for (let index = 0; index < end; index++) {
+		const segment = segments[index];
+		const paramName = getAppPageSegmentParamName(segment);
+		if (!paramName) continue;
+		const paramValue = matchedParams[paramName];
+		if (paramValue === void 0 || isEmptyOptionalCatchAll(segment, paramValue)) continue;
+		segmentParams[paramName] = paramValue;
+	}
+	return segmentParams;
+}
+//#endregion
+export { getAppPageSegmentParamName, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams };

package/dist/server/app-page-ppr-runtime.d.ts

@@ -0,0 +1,7 @@
+import { createAppPprFallbackShells } from "./app-ppr-fallback-shell.js";
+import { AppPageDispatchRoute, AppPagePprRuntime } from "./app-page-dispatch.js";
+
+//#region src/server/app-page-ppr-runtime.d.ts
+declare const appPagePprRuntime: AppPagePprRuntime<AppPageDispatchRoute>;
+//#endregion
+export { appPagePprRuntime, createAppPprFallbackShells };

package/dist/server/app-page-ppr-runtime.js

@@ -0,0 +1,70 @@
+import { beginPprFallbackShellFinalRender, createPprFallbackShellState, getPprFallbackShellState, runWithPprFallbackShellState } from "../shims/ppr-fallback-shell.js";
+import { createAppPprFallbackShells } from "./app-ppr-fallback-shell.js";
+import { hasSearchParams, shouldReadAppPageCache } from "./app-page-dispatch.js";
+//#region src/server/app-page-ppr-runtime.ts
+function classifyPprFallbackShellEligibility(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) {
+	if (options.renderedConcreteUrlPaths?.has(options.cleanPathname) === true) return { kind: "skip-known-pregenerated-route" };
+	const fallbackShells = options.pprFallbackCacheShells;
+	if (!fallbackShells || fallbackShells.length === 0) return { kind: "skip-no-fallback-shells" };
+	if (options.isRscRequest) return { kind: "skip-rsc-request" };
+	if (options.request.method !== "GET") return { kind: "skip-non-get" };
+	if (!isForceStatic && hasSearchParams(options.searchParams)) return { kind: "skip-search-params" };
+	if (!shouldReadAppPageCache({
+		isDraftMode,
+		isForceDynamic,
+		isProgressiveActionRender: options.isProgressiveActionRender === true,
+		isProduction: options.isProduction,
+		isRscRequest: false,
+		revalidateSeconds: currentRevalidateSeconds,
+		scriptNonce: options.scriptNonce
+	})) return { kind: "skip-cache-disabled" };
+	return {
+		kind: "probe-fallback-shells",
+		fallbackShells
+	};
+}
+async function probePprFallbackShellCache(options, fallbackShells, currentRevalidateSeconds) {
+	const { readAppPageFallbackShellCacheResponse } = await import("./app-page-cache.js");
+	const { rewriteAppPprFallbackShellHtmlNavigation } = await import("./app-ppr-fallback-shell.js");
+	for (const fallbackShell of fallbackShells) {
+		const fallbackShellResponse = await readAppPageFallbackShellCacheResponse({
+			clearRequestContext: options.clearRequestContext,
+			expireSeconds: options.expireSeconds,
+			fallbackPathname: fallbackShell.pathname,
+			isEdgeRuntime: options.isEdgeRuntime,
+			isrDebug: options.isrDebug,
+			isrGet: options.isrGet,
+			isrHtmlKey: options.isrHtmlKey,
+			middlewareHeaders: options.middlewareContext.headers,
+			middlewareStatus: options.middlewareContext.status,
+			revalidateSeconds: currentRevalidateSeconds ?? 0,
+			rewriteHtml(html) {
+				return rewriteAppPprFallbackShellHtmlNavigation({
+					html,
+					params: options.params,
+					pathname: options.cleanPathname,
+					searchParams: options.searchParams
+				});
+			}
+		});
+		if (fallbackShellResponse) return fallbackShellResponse;
+	}
+	return null;
+}
+const appPagePprRuntime = {
+	beginFinalRender: beginPprFallbackShellFinalRender,
+	getState: getPprFallbackShellState,
+	run(shell, fn) {
+		return runWithPprFallbackShellState(createPprFallbackShellState(shell), fn);
+	},
+	async tryServe(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) {
+		const decision = classifyPprFallbackShellEligibility(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic);
+		return decision.kind === "probe-fallback-shells" ? probePprFallbackShellCache(options, decision.fallbackShells, currentRevalidateSeconds) : null;
+	},
+	async warm(options) {
+		const { warmPprFallbackShellCaches } = await import("./app-ppr-fallback-shell-render.js");
+		await warmPprFallbackShellCaches(options);
+	}
+};
+//#endregion
+export { appPagePprRuntime, createAppPprFallbackShells };

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

@@ -0,0 +1,134 @@
+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.
+ *
+ * The generated RSC entry calls this once per request after route matching to
+ * eagerly invoke the page component. Surfacing redirect()/notFound() throws
+ * here lets the probe lifecycle turn them into proper HTTP responses before
+ * RSC streaming begins (see `probeAppPageBeforeRender`).
+ *
+ * The helper exists to keep the generated entry thin (a single delegation
+ * call) and to make the search-params wiring directly unit-testable. A bug
+ * here previously slipped through because the entry hand-rolled the call and
+ * read a non-existent key off `collectAppPageSearchParams`'s return value
+ * (see https://github.com/cloudflare/vinext/issues/1235).
+ *
+ * Returns `null` when the route has no page component (eg. interception-only
+ * routes), matching the caller contract on `probePage`.
+ */
+declare function probeAppPage(options: {
+  pageComponent: unknown;
+  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;
+};
+type ProbeAppPageBeforeRenderOptions = {
+  hasLoadingBoundary: boolean;
+  skipProbes?: boolean;
+  layoutCount: number;
+  probeLayoutAt: (layoutIndex: number) => unknown;
+  probePage: () => unknown;
+  renderLayoutSpecialError: (specialError: AppPageSpecialError, layoutIndex: number) => Promise<Response>;
+  renderPageSpecialError: (specialError: AppPageSpecialError) => Promise<Response>;
+  resolveSpecialError: (error: unknown) => AppPageSpecialError | null;
+  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>; /** When provided, enables per-layout static/dynamic classification. */
+  classification?: LayoutClassificationOptions | null;
+};
+declare function probeAppPageBeforeRender(options: ProbeAppPageBeforeRenderOptions): Promise<ProbeAppPageBeforeRenderResult>;
+//#endregion
+export { buildAppPageProbes, probeAppPage, probeAppPageBeforeRender, probeReactServerSubtree };

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

@@ -0,0 +1,276 @@
+import { markAppPagePropsForUseCache } from "../shims/internal/app-page-props-cache-key.js";
+import { isNextRouterError } from "../shims/navigation-errors.js";
+import "../shims/navigation-server.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.
+*
+* The generated RSC entry calls this once per request after route matching to
+* eagerly invoke the page component. Surfacing redirect()/notFound() throws
+* here lets the probe lifecycle turn them into proper HTTP responses before
+* RSC streaming begins (see `probeAppPageBeforeRender`).
+*
+* The helper exists to keep the generated entry thin (a single delegation
+* call) and to make the search-params wiring directly unit-testable. A bug
+* here previously slipped through because the entry hand-rolled the call and
+* read a non-existent key off `collectAppPageSearchParams`'s return value
+* (see https://github.com/cloudflare/vinext/issues/1235).
+*
+* Returns `null` when the route has no page component (eg. interception-only
+* routes), matching the caller contract on `probePage`.
+*/
+function probeAppPage(options) {
+	const { pageComponent, asyncRouteParams, searchParams } = options;
+	if (typeof pageComponent !== "function") return null;
+	const { pageSearchParams } = collectAppPageSearchParams(searchParams);
+	const result = pageComponent(markAppPagePropsForUseCache({
+		params: asyncRouteParams,
+		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 = {};
+	if (options.skipProbes) return {
+		response: null,
+		layoutFlags
+	};
+	if (options.layoutCount > 0) {
+		const layoutProbeResult = await probeAppPageLayouts({
+			layoutCount: options.layoutCount,
+			async onLayoutError(layoutError, layoutIndex) {
+				const specialError = options.resolveSpecialError(layoutError);
+				if (!specialError) return null;
+				return options.renderLayoutSpecialError(specialError, layoutIndex);
+			},
+			probeLayoutAt: options.probeLayoutAt,
+			runWithSuppressedHookWarning(probe) {
+				return options.runWithSuppressedHookWarning(probe);
+			},
+			classification: options.classification
+		});
+		layoutFlags = layoutProbeResult.layoutFlags;
+		if (layoutProbeResult.response) return {
+			response: layoutProbeResult.response,
+			layoutFlags
+		};
+	}
+	if (options.hasLoadingBoundary) return {
+		response: null,
+		layoutFlags
+	};
+	return {
+		response: await probeAppPageComponent({
+			awaitAsyncResult: true,
+			async onError(pageError) {
+				const specialError = options.resolveSpecialError(pageError);
+				if (specialError) return options.renderPageSpecialError(specialError);
+				return null;
+			},
+			probePage: options.probePage,
+			runWithSuppressedHookWarning(probe) {
+				return options.runWithSuppressedHookWarning(probe);
+			}
+		}),
+		layoutFlags
+	};
+}
+//#endregion
+export { buildAppPageProbes, probeAppPage, probeAppPageBeforeRender, probeReactServerSubtree };

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

@@ -0,0 +1,21 @@
+import { AppElementsInterception } from "./app-elements-wire.js";
+//#region src/server/app-page-render-identity.d.ts
+type AppPageRenderIdentityInput = {
+  displayPathname: string;
+  interceptionContext?: string | null;
+  interceptSourceMatchedUrl?: string | null;
+  interceptSlotId?: string | null;
+};
+type AppPageRenderIdentity = {
+  displayPathname: string;
+  interception: AppElementsInterception | null;
+  interceptionContext: string | null;
+  matchedRoutePathname: string;
+  pageId: string;
+  routeId: string;
+  targetMatchedPathname: string;
+};
+declare function normalizeAppPageInterceptionProofPathname(pathname: string | null): string | null;
+declare function createAppPageRenderIdentity(input: AppPageRenderIdentityInput): AppPageRenderIdentity;
+//#endregion
+export { AppPageRenderIdentity, createAppPageRenderIdentity, normalizeAppPageInterceptionProofPathname };

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

@@ -0,0 +1,40 @@
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
+import { isInterceptionMatchedUrlPath, normalizePath } from "./normalize-path.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+//#region src/server/app-page-render-identity.ts
+function normalizeAppPageRenderMatchedPathname(pathname) {
+	if (!pathname.startsWith("/")) throw new Error(`[vinext] App Router render pathname must be absolute: ${pathname}`);
+	return normalizePath(normalizePathnameForRouteMatch(pathname));
+}
+function normalizeAppPageInterceptionProofPathname(pathname) {
+	if (pathname === null || !isInterceptionMatchedUrlPath(pathname)) return null;
+	return normalizeAppPageRenderMatchedPathname(pathname);
+}
+function createAppPageRenderIdentity(input) {
+	const interceptionContext = input.interceptionContext ?? null;
+	const targetMatchedPathname = normalizeAppPageRenderMatchedPathname(input.displayPathname);
+	const sourceMatchedPathname = normalizeAppPageInterceptionProofPathname(input.interceptSourceMatchedUrl ?? null);
+	const slotId = input.interceptSlotId ?? null;
+	const matchedRoutePathname = sourceMatchedPathname ?? targetMatchedPathname;
+	const routeId = AppElementsWire.encodeRouteId(matchedRoutePathname, null);
+	const pageId = AppElementsWire.encodePageId(matchedRoutePathname, null);
+	const interception = sourceMatchedPathname === null || slotId === null ? null : {
+		sourceMatchedUrl: sourceMatchedPathname,
+		sourceRouteId: AppElementsWire.encodeRouteId(sourceMatchedPathname, null),
+		slotId,
+		targetMatchedUrl: targetMatchedPathname,
+		targetRouteId: AppElementsWire.encodeRouteId(targetMatchedPathname, null)
+	};
+	return {
+		displayPathname: input.displayPathname,
+		interception,
+		interceptionContext,
+		matchedRoutePathname,
+		pageId,
+		routeId,
+		targetMatchedPathname
+	};
+}
+//#endregion
+export { createAppPageRenderIdentity, normalizeAppPageInterceptionProofPathname };

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

@@ -0,0 +1,36 @@
+import { BoundaryOutcome, CacheProofOutputScope, RenderCacheability, RenderObservation, RenderObservationCompleteness, RenderRequestApiKind } from "./cache-proof.js";
+import { ReactNode } from "react";
+
+//#region src/server/app-page-render-observation.d.ts
+type AppPageRenderObservationState = Readonly<{
+  dynamicFetches: readonly string[];
+  requestApis: readonly RenderRequestApiKind[];
+}>;
+declare function createEmptyAppPageRenderObservationState(): AppPageRenderObservationState;
+declare function consumeAppPageRenderObservationState(): AppPageRenderObservationState;
+declare function discardAppPageRenderState(): void;
+declare function createAppPageRenderObservation(options: {
+  boundaryOutcome: BoundaryOutcome;
+  cacheTags: readonly string[];
+  cacheability: RenderCacheability;
+  cleanPathname: string;
+  completeness: RenderObservationCompleteness;
+  output: CacheProofOutputScope;
+  params: Record<string, unknown>;
+  state: AppPageRenderObservationState;
+}): RenderObservation;
+declare function createAppPageRscOutputScope(options: {
+  element: ReactNode | Readonly<Record<string, ReactNode>>;
+  mountedSlotsHeader?: string | null;
+  renderEpoch: string | null;
+  rootBoundaryId: string | null;
+  routePattern: string;
+}): CacheProofOutputScope;
+declare function createAppPageHtmlOutputScope(options: {
+  element: ReactNode | Readonly<Record<string, ReactNode>>;
+  renderEpoch: string | null;
+  rootBoundaryId: string | null;
+  routePattern: string;
+}): CacheProofOutputScope;
+//#endregion
+export { AppPageRenderObservationState, consumeAppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState, discardAppPageRenderState };