vinext 0.1.7 → 0.1.8

package/dist/server/app-browser-server-action-client.js

@@ -0,0 +1,128 @@
+import { ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER } from "./headers.js";
+import { DANGEROUS_URL_BLOCK_MESSAGE, isDangerousScheme } from "../shims/url-safety.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createServerActionRequestUrl } from "./app-rsc-cache-busting.js";
+import { createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
+import { resolveServerActionRequestState } from "./app-browser-state.js";
+import { applyServerActionResultDecision } from "./app-browser-server-action-navigation.js";
+import { throwOnServerActionNotFound } from "./server-action-not-found.js";
+import { createFromFetch, createTemporaryReferenceSet, encodeReply } from "@vitejs/plugin-rsc/browser";
+//#region src/server/app-browser-server-action-client.ts
+function resolveActionRedirectTarget(response, performHardNavigation) {
+	const actionRedirect = response.headers.get(ACTION_REDIRECT_HEADER);
+	if (!actionRedirect) return null;
+	if (isDangerousScheme(actionRedirect)) {
+		console.error(DANGEROUS_URL_BLOCK_MESSAGE);
+		return null;
+	}
+	try {
+		let redirectUrl;
+		if (actionRedirect.startsWith("/") || /^[a-z]+:/i.test(actionRedirect)) redirectUrl = new URL(actionRedirect, window.location.href);
+		else {
+			const baseParsed = new URL(window.location.href);
+			let baseDir = baseParsed.pathname;
+			if (!baseDir.endsWith("/")) baseDir += "/";
+			redirectUrl = new URL(actionRedirect, `${baseParsed.origin}${baseDir}${baseParsed.search}`);
+		}
+		if (redirectUrl.origin !== window.location.origin) {
+			performHardNavigation(actionRedirect);
+			return null;
+		}
+		const statusHeader = response.headers.get(ACTION_REDIRECT_STATUS_HEADER);
+		return {
+			href: redirectUrl.href,
+			type: response.headers.get("x-action-redirect-type") ?? "push",
+			status: statusHeader ? parseInt(statusHeader, 10) : 307
+		};
+	} catch {
+		performHardNavigation(actionRedirect);
+		return null;
+	}
+}
+var ServerActionRedirectError = class extends Error {
+	digest;
+	handled = true;
+	constructor(target) {
+		super("NEXT_REDIRECT");
+		const redirectUrl = new URL(target.href, window.location.href);
+		const redirectHref = redirectUrl.pathname + redirectUrl.search + redirectUrl.hash;
+		const redirectType = target.type === "push" ? "push" : "replace";
+		this.digest = `NEXT_REDIRECT;${redirectType};${encodeURIComponent(redirectHref)};${target.status};`;
+	}
+};
+async function invokeClientServerAction(id, args, actionInitiation, deps) {
+	deps.syncServerActionHttpFallbackHead(null);
+	const temporaryReferences = createTemporaryReferenceSet();
+	deps.syncCurrentHistoryState(actionInitiation.routerState.previousNextUrl, actionInitiation.routerState.bfcacheIds);
+	const body = await encodeReply(args, { temporaryReferences });
+	const headers = resolveServerActionRequestState({
+		actionId: id,
+		basePath: deps.basePath,
+		elements: actionInitiation.routerState.elements,
+		previousNextUrl: actionInitiation.routerState.previousNextUrl
+	}).headers;
+	const fetchResponse = await fetch(createServerActionRequestUrl(actionInitiation.path), {
+		method: "POST",
+		headers,
+		body
+	});
+	throwOnServerActionNotFound(fetchResponse, id);
+	const hasActionRedirect = fetchResponse.headers.has(ACTION_REDIRECT_HEADER);
+	const actionRedirectTarget = resolveActionRedirectTarget(fetchResponse, (url, historyMode) => deps.performHardNavigation(url, historyMode));
+	if (hasActionRedirect && !actionRedirectTarget) return void 0;
+	const actionResultFacts = createServerActionResultFacts({
+		actionRedirectHref: actionRedirectTarget?.href ?? null,
+		actionRedirectType: actionRedirectTarget?.type ?? null,
+		clientCompatibilityId: deps.clientRscCompatibilityId,
+		compatibilityIdHeader: fetchResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
+		contentTypeHeader: fetchResponse.headers.get("content-type"),
+		currentHref: actionInitiation.href,
+		origin: window.location.origin,
+		responseUrl: fetchResponse.url
+	});
+	const fetchResponseIsRsc = actionResultFacts.isRscContentType;
+	if (applyServerActionResultDecision(deps.navigationPlanner.classifyServerActionResult(actionResultFacts), () => deps.clearClientNavigationCaches(), (url, historyMode) => deps.performHardNavigation(url, historyMode))) return;
+	const revalidation = parseServerActionRevalidationHeader(fetchResponse.headers);
+	if (revalidation !== "none") deps.clearClientNavigationCaches();
+	const invalidResponseError = await readInvalidServerActionResponseError(fetchResponse.clone(), actionRedirectTarget !== null);
+	if (invalidResponseError) throw invalidResponseError;
+	if (actionRedirectTarget && !fetchResponseIsRsc) {
+		deps.performHardNavigation(actionRedirectTarget.href);
+		return;
+	}
+	const flightResponse = fetchResponse.status === 303 ? new Response(fetchResponse.body, {
+		headers: fetchResponse.headers,
+		status: 200,
+		statusText: "OK"
+	}) : fetchResponse;
+	const result = await createFromFetch(Promise.resolve(flightResponse), { temporaryReferences });
+	if (revalidation === "none" && shouldClearClientNavigationCachesForServerActionResult(result, revalidation)) deps.clearClientNavigationCaches();
+	if (actionRedirectTarget) {
+		if (isServerActionResult(result) && result.root !== void 0) {
+			deps.renderRedirectPayload(AppElementsWire.decode(result.root), actionRedirectTarget, actionInitiation);
+			throw new ServerActionRedirectError(actionRedirectTarget);
+		}
+		deps.performHardNavigation(actionRedirectTarget.href);
+		return;
+	}
+	const hasSameUrlRerenderPayload = isServerActionResult(result) && result.root !== void 0;
+	deps.syncServerActionHttpFallbackHead(hasSameUrlRerenderPayload ? null : fetchResponse.status);
+	if (isServerActionResult(result)) {
+		if (result.root !== void 0) {
+			const returnValue = result.returnValue && !result.returnValue.ok ? {
+				ok: false,
+				data: normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status)
+			} : result.returnValue;
+			return deps.commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result.root)), actionInitiation, returnValue, revalidation);
+		}
+		if (result.returnValue) {
+			if (!result.returnValue.ok) throw normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status);
+			return result.returnValue.data;
+		}
+		return;
+	}
+	return deps.commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result)), actionInitiation, void 0, revalidation);
+}
+//#endregion
+export { invokeClientServerAction };

package/dist/server/app-fallback-renderer.d.ts

@@ -4,6 +4,7 @@ import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
+import { ApplyAppPageFileBasedMetadata } from "./app-page-head.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppPageBoundaryRoute } from "./app-page-boundary-render.js";
 import { ReactNode } from "react";
@@ -27,6 +28,7 @@ type AppFallbackRendererFontProviders = {
   getFontStyles: () => string[];
 };
 type AppFallbackRendererOptions<TModule extends AppPageModule = AppPageModule> = {
+  applyFileBasedMetadata?: ApplyAppPageFileBasedMetadata;
   clearRequestContext: () => void;
   createRscOnErrorHandler: (request: Request, pathname: string, routePath: string) => AppPageBoundaryOnError;
   fontProviders: AppFallbackRendererFontProviders;
@@ -73,7 +75,7 @@ type AppFallbackRendererCallContext = {
   sourcePageSegments?: readonly string[] | null;
 };
 type AppFallbackRenderer<TModule extends AppPageModule = AppPageModule> = {
-  renderErrorBoundary: (route: AppPageBoundaryRoute<TModule> | null, error: unknown, isRscRequest: boolean, request: Request, matchedParams: AppPageParams | undefined, scriptNonce: string | undefined, middlewareContext: AppPageMiddlewareContext, callContext?: AppFallbackRendererCallContext) => Promise<Response | null>;
+  renderErrorBoundary: (route: AppPageBoundaryRoute<TModule> | null, error: unknown, isRscRequest: boolean, request: Request, matchedParams: AppPageParams | undefined, scriptNonce: string | undefined, middlewareContext: AppPageMiddlewareContext, callContext?: AppFallbackRendererCallContext, errorOrigin?: "rsc" | "ssr") => Promise<Response | null>;
   renderHttpAccessFallback: (route: AppPageBoundaryRoute<TModule> | null, statusCode: number, isRscRequest: boolean, request: Request, opts: {
     boundaryComponent?: AppPageComponent | null;
     boundaryModule?: TModule | null;

package/dist/server/app-fallback-renderer.js

@@ -7,7 +7,7 @@ const EMPTY_MW_CTX = {
 	status: null
 };
 function createAppFallbackRenderer(options) {
-	const { basePath = "", clearRequestContext, createRscOnErrorHandler: buildRscOnErrorHandler, fontProviders, getNavigationContext, globalErrorModule, loadGlobalNotFoundModule, makeThenableParams, metadataRoutes, resolveChildSegments, rootBoundaries, rscRenderer, sanitizer, ssrLoader, trailingSlash } = options;
+	const { applyFileBasedMetadata, basePath = "", clearRequestContext, createRscOnErrorHandler: buildRscOnErrorHandler, fontProviders, getNavigationContext, globalErrorModule, loadGlobalNotFoundModule, makeThenableParams, metadataRoutes, resolveChildSegments, rootBoundaries, rscRenderer, sanitizer, ssrLoader, trailingSlash } = options;
 	const { rootForbiddenModule, rootLayouts, rootNotFoundModule, rootUnauthorizedModule } = rootBoundaries;
 	const effectiveGlobalErrorModule = globalErrorModule ?? DEFAULT_GLOBAL_ERROR_MODULE;
 	const effectiveRootNotFoundModule = rootNotFoundModule ?? DEFAULT_NOT_FOUND_MODULE;
@@ -23,6 +23,7 @@ function createAppFallbackRenderer(options) {
 				const globalNotFoundModule = await resolveGlobalNotFoundModule();
 				const globalNotFoundComponent = globalNotFoundModule?.default ?? null;
 				if (globalNotFoundComponent) return renderAppPageHttpAccessFallback({
+					applyFileBasedMetadata,
 					boundaryComponent: globalNotFoundComponent,
 					boundaryModule: globalNotFoundModule ?? null,
 					buildFontLinkHeader: fontProviders.buildFontLinkHeader,
@@ -57,6 +58,7 @@ function createAppFallbackRenderer(options) {
 				});
 			}
 			return renderAppPageHttpAccessFallback({
+				applyFileBasedMetadata,
 				basePath,
 				trailingSlash,
 				boundaryComponent: opts?.boundaryComponent ?? null,
@@ -95,8 +97,9 @@ function createAppFallbackRenderer(options) {
 		renderNotFound(route, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext) {
 			return this.renderHttpAccessFallback(route, 404, isRscRequest, request, { matchedParams }, scriptNonce, middlewareContext, callContext);
 		},
-		renderErrorBoundary(route, error, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext) {
+		renderErrorBoundary(route, error, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext, errorOrigin = "rsc") {
 			return renderAppPageErrorBoundary({
+				applyFileBasedMetadata,
 				basePath,
 				trailingSlash,
 				buildFontLinkHeader: fontProviders.buildFontLinkHeader,
@@ -105,6 +108,7 @@ function createAppFallbackRenderer(options) {
 					return buildRscOnErrorHandler(request, pathname, routePath);
 				},
 				error,
+				errorOrigin,
 				getFontLinks: fontProviders.getFontLinks,
 				getFontPreloads: fontProviders.getFontPreloads,
 				getFontStyles: fontProviders.getFontStyles,

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

@@ -4,6 +4,7 @@ import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
+import { ApplyAppPageFileBasedMetadata } from "./app-page-head.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { ComponentType, ReactNode } from "react";
 
@@ -27,6 +28,7 @@ type AppPageBoundaryRoute<TModule extends AppPageModule = AppPageModule> = {
   unauthorized?: TModule | null;
 };
 type AppPageBoundaryRenderCommonOptions<TModule extends AppPageModule = AppPageModule> = {
+  applyFileBasedMetadata?: ApplyAppPageFileBasedMetadata;
   buildFontLinkHeader: (preloads: readonly AppPageFontPreload[] | null | undefined) => string;
   clearRequestContext: () => void;
   createRscOnErrorHandler: (pathname: string, routePath: string) => AppPageBoundaryOnError;
@@ -73,6 +75,7 @@ type RenderAppPageHttpAccessFallbackOptions<TModule extends AppPageModule = AppP
 } & AppPageBoundaryRenderCommonOptions<TModule>;
 type RenderAppPageErrorBoundaryOptions<TModule extends AppPageModule = AppPageModule> = {
   error: unknown;
+  errorOrigin?: "rsc" | "ssr";
   matchedParams?: AppPageParams | null;
   route?: AppPageBoundaryRoute<TModule> | null;
   sanitizeErrorForClient: (error: Error) => Error;

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

@@ -3,7 +3,7 @@ import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
-import { ErrorBoundary, GlobalErrorBoundary } from "../shims/error-boundary.js";
+import { ErrorBoundary, GlobalErrorBoundary, SerializedErrorBoundary } from "../shims/error-boundary.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead } from "../shims/metadata.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
@@ -152,6 +152,7 @@ async function renderAppPageHttpAccessFallback(options) {
 	const pathname = new URL(options.requestUrl).pathname;
 	const routeSegments = resolveHttpAccessFallbackHeadRouteSegments(options.route, layoutModules);
 	const { metadata, viewport } = await resolveAppPageHead({
+		applyFileBasedMetadata: options.applyFileBasedMetadata,
 		basePath: options.basePath ?? "",
 		layoutModules,
 		layoutTreePositions: resolveHttpAccessFallbackHeadLayoutTreePositions(options.route, layoutModules),
@@ -214,7 +215,7 @@ async function renderAppPageErrorBoundary(options) {
 	if (!errorBoundary.component) return null;
 	const rawError = options.error instanceof Error ? options.error : new Error(String(options.error));
 	rewriteClientHookError(rawError);
-	const errorObject = options.sanitizeErrorForClient(rawError);
+	const errorObject = options.errorOrigin === "ssr" ? rawError : options.sanitizeErrorForClient(rawError);
 	const matchedParams = options.matchedParams ?? options.route?.params ?? {};
 	const layoutModules = options.route?.layouts ?? options.rootLayouts;
 	const pathname = new URL(options.requestUrl).pathname;
@@ -224,6 +225,7 @@ async function renderAppPageErrorBoundary(options) {
 	})];
 	if (!errorBoundary.isGlobalError) try {
 		const { metadata, viewport } = await resolveAppPageHead({
+			applyFileBasedMetadata: options.applyFileBasedMetadata,
 			basePath: options.basePath ?? "",
 			fallbackOnFileMetadataError: true,
 			layoutModules,
@@ -247,7 +249,16 @@ async function renderAppPageErrorBoundary(options) {
 		console.error(`[vinext] App page error boundary head resolution failed for ${options.route?.pattern ?? pathname}:`, error);
 	}
 	const buildElement = (BoundaryComponent) => {
-		const boundaryElement = createElement(BoundaryComponent, { error: errorObject });
+		const serializedError = {
+			digest: "digest" in errorObject ? String(errorObject.digest) : void 0,
+			message: errorObject.message,
+			name: errorObject.name,
+			stack: process.env.NODE_ENV !== "production" ? errorObject.stack : void 0
+		};
+		const boundaryElement = errorBoundary.isGlobalError && BoundaryComponent !== DEFAULT_GLOBAL_ERROR_COMPONENT ? createElement(SerializedErrorBoundary, {
+			error: serializedError,
+			fallback: BoundaryComponent
+		}) : createElement(BoundaryComponent, { error: errorObject });
 		return wrapRenderedBoundaryElement({
 			element: createElement(Fragment, null, ...headElements, errorBoundary.isGlobalError ? createElement(GlobalErrorBoundary, {
 				fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,

package/dist/server/app-page-cache-finalizer.d.ts

@@ -30,6 +30,7 @@ type FinalizeAppPageHtmlCacheResponseOptions = {
   isrRscKey: AppPageRscCacheKeyBuilder;
   isrSet: AppPageCacheSetter;
   interceptionContext?: string | null;
+  omitPendingDynamicCacheState?: boolean;
   preserveClientResponseHeaders?: boolean;
   expireSeconds?: number;
   revalidateSeconds: number | null;

package/dist/server/app-page-cache-finalizer.js

@@ -1,15 +1,21 @@
+import { NEXTJS_CACHE_HEADER, VINEXT_CACHE_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { buildAppPageCacheValue } from "./isr-cache.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
 //#region src/server/app-page-cache-finalizer.ts
-function applyPendingDynamicCdnHeaders(headers, tags) {
+function applyPendingDynamicCdnHeaders(headers, tags, options = {}) {
 	applyCdnResponseHeaders(headers, {
 		cacheControl: headers.get("Cache-Control") ?? "",
 		pendingDynamicCheck: true,
 		tags
 	});
+	if (options.omitCacheState === true) {
+		headers.delete(VINEXT_CACHE_HEADER);
+		headers.delete(NEXTJS_CACHE_HEADER);
+		return;
+	}
 	setCacheStateHeaders(headers, "MISS");
 }
 function resolveAppPageCacheWritePolicy(options) {
@@ -30,7 +36,7 @@ function finalizeAppPageHtmlCacheResponse(response, options) {
 	const htmlKey = options.isrHtmlKey(options.cleanPathname);
 	const rscKey = options.isrRscKey(options.cleanPathname, null, void 0, options.interceptionContext);
 	const clientHeaders = new Headers(response.headers);
-	if (options.preserveClientResponseHeaders !== true) applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags());
+	if (options.preserveClientResponseHeaders !== true) applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags(), { omitCacheState: options.omitPendingDynamicCacheState === true });
 	const cachePromise = (async () => {
 		try {
 			const cachedHtml = await readStreamAsText(streamForCache);

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

@@ -10,8 +10,10 @@ import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { ISRCacheEntry } from "./isr-cache.js";
+import { PprFallbackShellState } from "../shims/ppr-fallback-shell.js";
 import { FetchCacheMode } from "../shims/fetch-cache.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
+import { WarmPprFallbackShellCachesOptions } from "./app-ppr-fallback-shell-render.js";
 import { ValidateAppPageDynamicParamsOptions } from "./app-page-request.js";
 import { ReactNode } from "react";
 import { ReactFormState } from "react-dom/client";
@@ -32,7 +34,10 @@ type AppPageBackgroundRegenerationErrorContext = {
 type AppPageBackgroundRegenerator = (key: string, renderFn: () => Promise<void>, errorContext?: AppPageBackgroundRegenerationErrorContext) => void;
 type AppPageDispatchIntercept<TPage = unknown> = {
   interceptLayouts?: readonly unknown[] | null;
+  interceptLayoutSegments?: readonly (readonly string[])[] | null;
+  interceptBranchSegments?: readonly string[] | null;
   matchedParams: AppPageParams;
+  sourceMatchedParams?: AppPageParams;
   page: TPage;
   slotId?: string | null;
   slotKey: string;
@@ -42,6 +47,8 @@ type AppPageDispatchIntercept<TPage = unknown> = {
 type AppPageDispatchInterceptOptions<TPage = unknown> = {
   interceptionContext: string | null;
   interceptLayouts?: readonly unknown[] | null;
+  interceptLayoutSegments?: readonly (readonly string[])[] | null;
+  interceptBranchSegments?: readonly string[] | null;
   interceptPage: TPage;
   interceptParams: AppPageParams;
   interceptSlotId?: string | null;
@@ -80,6 +87,14 @@ type AppPageDispatchRoute = {
   unauthorized?: AppPageModule | null;
   unauthorizeds?: readonly (AppPageModule | null | undefined)[];
 };
+type AppPagePprRuntime<TRoute extends AppPageDispatchRoute> = {
+  beginFinalRender(state: AppPagePprState): void;
+  getState(): AppPagePprState | null;
+  run<T>(shell: NonNullable<DispatchAppPageOptions<TRoute>["pprFallbackShell"]>, fn: () => T): T;
+  tryServe(options: DispatchAppPageOptions<TRoute>, currentRevalidateSeconds: number | null, isDraftMode: boolean, isForceStatic: boolean, isForceDynamic: boolean): Promise<Response | null>;
+  warm(options: WarmPprFallbackShellCachesOptions): Promise<void>;
+};
+type AppPagePprState = PprFallbackShellState;
 type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   /** Configured basePath (e.g. "/blog"). Used to prefix redirect Locations. */basePath?: string;
   /**
@@ -94,7 +109,10 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
    * `next.config`. Undefined falls back to the React default downstream.
    */
   reactMaxHeadersLength?: number;
-  buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker) => Promise<AppPageElement>;
+  buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker, options?: {
+    observeMetadataSearchParamsAccess?: boolean;
+    observePageSearchParamsAccess?: boolean;
+  }) => Promise<AppPageElement>;
   clientReuseManifest?: ClientReuseManifestParseResult;
   cleanPathname: string;
   displayPathname?: string;
@@ -147,6 +165,7 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
     fallbackParamNames: readonly string[];
     routePattern: string;
   };
+  pprRuntime?: AppPagePprRuntime<TRoute>;
   /**
    * Set of concrete URL paths that were pre-rendered at build time for this
    * route. When the exact cache entry for a known pregenerated path is absent
@@ -159,9 +178,9 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
   probeLayoutAt: (layoutIndex: number, layoutParamAccess?: AppLayoutParamAccessTracker) => unknown;
-  probePage: () => unknown;
+  probePage: (searchParams?: URLSearchParams) => unknown;
   expireSeconds?: number;
-  renderErrorBoundaryPage: (error: unknown) => Promise<Response | null>;
+  renderErrorBoundaryPage: (error: unknown, errorOrigin?: "rsc" | "ssr") => Promise<Response | null>;
   renderHttpAccessFallbackPage: (statusCode: number, opts: {
     boundaryComponent?: unknown;
     boundaryModule?: AppPageModule | null;
@@ -197,6 +216,16 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   }) => void;
   renderMode?: AppRscRenderMode;
 };
+declare function shouldReadAppPageCache(options: {
+  isProgressiveActionRender: boolean;
+  isDraftMode: boolean;
+  isForceDynamic: boolean;
+  isProduction: boolean;
+  isRscRequest: boolean;
+  revalidateSeconds: number | null;
+  scriptNonce?: string;
+}): boolean;
+declare function hasSearchParams(searchParams: URLSearchParams | null | undefined): boolean;
 declare function dispatchAppPage<TRoute extends AppPageDispatchRoute>(options: DispatchAppPageOptions<TRoute>): Promise<Response>;
 //#endregion
-export { dispatchAppPage };
+export { AppPageBoundaryOnError, AppPageDispatchRoute, AppPagePprRuntime, AppPagePprState, AppPageRenderableElement, DispatchAppPageOptions, dispatchAppPage, hasSearchParams, shouldReadAppPageCache };