@qzsy/vinext 0.1.7

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

@@ -0,0 +1,272 @@
+import { VINEXT_MOUNTED_SLOTS_HEADER } from "./headers.js";
+import { setCacheStateHeaders } from "./cache-headers.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
+import { decideIsr } from "./isr-decision.js";
+import { buildAppPageCacheValue } from "./isr-cache.js";
+import { encodeCacheTag } from "../utils/encode-cache-tag.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { applyEdgeRuntimeHeader } from "./app-page-response.js";
+import { hasCompleteNegativeRequestApiProof } from "./cache-proof.js";
+import { isAppPprDynamicFallbackShellHtml } from "./app-ppr-fallback-shell.js";
+import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, scheduleAppPageRscCacheWrite } from "./app-page-cache-finalizer.js";
+//#region src/server/app-page-cache.ts
+function recordAppPageCacheOutcome(recordCacheOutcome, input) {
+	try {
+		recordCacheOutcome?.(input);
+	} catch {}
+}
+function buildAppPageCacheTags(pathname, extraTags) {
+	const tags = [
+		pathname,
+		`_N_T_${pathname}`,
+		"_N_T_/layout"
+	];
+	const segments = pathname.split("/");
+	let built = "";
+	for (let index = 1; index < segments.length; index++) {
+		const segment = segments[index];
+		if (segment) {
+			built += `/${segment}`;
+			tags.push(`_N_T_${built}/layout`);
+		}
+	}
+	tags.push(`_N_T_${built}/page`);
+	for (const tag of extraTags) if (!tags.includes(tag)) tags.push(tag);
+	return tags.map(encodeCacheTag);
+}
+function buildAppPageCachedHeaders(options) {
+	const headers = new Headers({
+		"Content-Type": options.contentType,
+		Vary: VINEXT_RSC_VARY_HEADER
+	});
+	applyCdnResponseHeaders(headers, { cacheControl: options.cacheControl });
+	setCacheStateHeaders(headers, options.cacheState);
+	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
+	if (options.mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
+	mergeMiddlewareResponseHeaders(headers, options.middlewareHeaders ?? null);
+	return headers;
+}
+function getCachedAppPageValue(entry) {
+	return entry?.value.value && entry.value.value.kind === "APP_PAGE" ? entry.value.value : null;
+}
+function hasQueryInvariantAppPageProof(cachedValue) {
+	return cachedValue.renderObservation !== void 0 && hasCompleteNegativeRequestApiProof(cachedValue.renderObservation, ["searchParams"]);
+}
+function buildAppPageCachedResponse(cachedValue, options) {
+	const status = options.middlewareStatus ?? (cachedValue.status || 200);
+	const { cacheControl } = decideIsr({
+		cacheState: options.cacheState,
+		kind: "app-page",
+		revalidateSeconds: options.revalidateSeconds,
+		expireSeconds: options.expireSeconds,
+		cacheControlMeta: options.cacheControl
+	});
+	if (options.isRscRequest) {
+		if (!cachedValue.rscData) return null;
+		const rscHeaders = buildAppPageCachedHeaders({
+			cacheControl,
+			cacheState: options.cacheState,
+			contentType: VINEXT_RSC_CONTENT_TYPE,
+			isEdgeRuntime: options.isEdgeRuntime,
+			middlewareHeaders: options.middlewareHeaders,
+			mountedSlotsHeader: options.mountedSlotsHeader
+		});
+		applyRscCompatibilityIdHeader(rscHeaders);
+		return new Response(cachedValue.rscData, {
+			status,
+			headers: rscHeaders
+		});
+	}
+	if (typeof cachedValue.html !== "string" || cachedValue.html.length === 0) return null;
+	const htmlHeaders = buildAppPageCachedHeaders({
+		cacheControl,
+		cacheState: options.cacheState,
+		contentType: "text/html; charset=utf-8",
+		isEdgeRuntime: options.isEdgeRuntime,
+		middlewareHeaders: options.middlewareHeaders
+	});
+	return new Response(cachedValue.html, {
+		status,
+		headers: htmlHeaders
+	});
+}
+async function serveAppPageCachedHtml(options, transformValue) {
+	if (typeof options.cachedValue.html !== "string" || options.cachedValue.html.length === 0) {
+		if (options.cached?.isStale) options.scheduleRegeneration();
+		options.isrDebug?.(options.emptyDebugMessage, options.pathname);
+		return null;
+	}
+	const cacheState = options.cached?.isStale ? "STALE" : "HIT";
+	if (options.cached?.isStale) options.scheduleRegeneration();
+	const response = buildAppPageCachedResponse(transformValue ? transformValue(options.cachedValue) : options.cachedValue, {
+		cacheState,
+		cacheControl: options.cached?.value.cacheControl,
+		expireSeconds: options.expireSeconds,
+		isEdgeRuntime: options.isEdgeRuntime,
+		isRscRequest: false,
+		middlewareHeaders: options.middlewareHeaders,
+		middlewareStatus: options.middlewareStatus,
+		revalidateSeconds: options.revalidateSeconds
+	});
+	if (!response) return null;
+	options.isrDebug?.(`${cacheState} (${options.stateDebugLabel})`, options.pathname);
+	options.clearRequestContext();
+	return response;
+}
+async function readAppPageCacheResponse(options) {
+	const isrKey = options.isRscRequest ? options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext) : options.isrHtmlKey(options.cleanPathname);
+	const artifact = options.isRscRequest ? "rsc" : "html";
+	try {
+		const cached = await options.isrGet(isrKey);
+		const cachedValue = getCachedAppPageValue(cached);
+		if (cached && !cachedValue) {
+			recordAppPageCacheOutcome(options.recordCacheOutcome, {
+				artifact,
+				cacheKey: isrKey,
+				outcome: "miss",
+				reason: "non-app-page-entry"
+			});
+			options.isrDebug?.("MISS (non app-page cache entry)", options.cleanPathname);
+			return null;
+		}
+		if (cachedValue && options.hasRequestSearchParams === true && !hasQueryInvariantAppPageProof(cachedValue)) {
+			recordAppPageCacheOutcome(options.recordCacheOutcome, {
+				artifact,
+				cacheKey: isrKey,
+				outcome: "miss",
+				reason: "query-variant-unproven"
+			});
+			options.isrDebug?.("MISS (query-bearing request lacks cache proof)", options.cleanPathname);
+			return null;
+		}
+		if (cachedValue && !cached?.isStale) {
+			const hitResponse = buildAppPageCachedResponse(cachedValue, {
+				cacheState: "HIT",
+				cacheControl: cached?.value.cacheControl,
+				expireSeconds: options.expireSeconds,
+				isEdgeRuntime: options.isEdgeRuntime,
+				isRscRequest: options.isRscRequest,
+				middlewareHeaders: options.middlewareHeaders,
+				middlewareStatus: options.middlewareStatus,
+				mountedSlotsHeader: options.mountedSlotsHeader,
+				revalidateSeconds: options.revalidateSeconds
+			});
+			if (hitResponse) {
+				recordAppPageCacheOutcome(options.recordCacheOutcome, {
+					artifact,
+					cacheKey: isrKey,
+					outcome: "hit",
+					reason: "served"
+				});
+				options.isrDebug?.(options.isRscRequest ? "HIT (RSC)" : "HIT (HTML)", options.cleanPathname);
+				options.clearRequestContext();
+				return hitResponse;
+			}
+			recordAppPageCacheOutcome(options.recordCacheOutcome, {
+				artifact,
+				cacheKey: isrKey,
+				outcome: "miss",
+				reason: "empty-entry"
+			});
+			options.isrDebug?.("MISS (empty cached entry)", options.cleanPathname);
+		}
+		if (cached?.isStale && cachedValue) {
+			options.scheduleBackgroundRegeneration(isrKey, async () => {
+				const revalidatedPage = await options.renderFreshPageForCache();
+				const revalidateSeconds = revalidatedPage.cacheControl?.revalidate ?? options.revalidateSeconds;
+				const expireSeconds = revalidatedPage.cacheControl?.expire ?? options.expireSeconds;
+				const writes = [options.isrSet(options.isRscRequest ? isrKey : options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext), buildAppPageCacheValue("", revalidatedPage.rscData, 200, revalidatedPage.rscRenderObservation), revalidateSeconds, revalidatedPage.tags, expireSeconds)];
+				if (!options.isRscRequest) writes.push(options.isrSet(isrKey, buildAppPageCacheValue(revalidatedPage.html, void 0, 200, revalidatedPage.htmlRenderObservation), revalidateSeconds, revalidatedPage.tags, expireSeconds));
+				await Promise.all(writes);
+				options.isrDebug?.("regen complete", options.cleanPathname);
+			});
+			const staleResponse = buildAppPageCachedResponse(cachedValue, {
+				cacheState: "STALE",
+				cacheControl: cached.value.cacheControl,
+				expireSeconds: options.expireSeconds,
+				isEdgeRuntime: options.isEdgeRuntime,
+				isRscRequest: options.isRscRequest,
+				middlewareHeaders: options.middlewareHeaders,
+				middlewareStatus: options.middlewareStatus,
+				mountedSlotsHeader: options.mountedSlotsHeader,
+				revalidateSeconds: options.revalidateSeconds
+			});
+			if (staleResponse) {
+				recordAppPageCacheOutcome(options.recordCacheOutcome, {
+					artifact,
+					cacheKey: isrKey,
+					outcome: "stale",
+					reason: "served"
+				});
+				options.isrDebug?.(options.isRscRequest ? "STALE (RSC)" : "STALE (HTML)", options.cleanPathname);
+				options.clearRequestContext();
+				return staleResponse;
+			}
+			recordAppPageCacheOutcome(options.recordCacheOutcome, {
+				artifact,
+				cacheKey: isrKey,
+				outcome: "miss",
+				reason: "stale-empty-entry"
+			});
+			options.isrDebug?.("STALE MISS (empty stale entry)", options.cleanPathname);
+		}
+		if (!cached) {
+			recordAppPageCacheOutcome(options.recordCacheOutcome, {
+				artifact,
+				cacheKey: isrKey,
+				outcome: "miss",
+				reason: "no-entry"
+			});
+			options.isrDebug?.("MISS (no cache entry)", options.cleanPathname);
+		}
+	} catch (isrReadError) {
+		recordAppPageCacheOutcome(options.recordCacheOutcome, {
+			artifact,
+			cacheKey: isrKey,
+			outcome: "miss",
+			reason: "read-error"
+		});
+		console.error("[vinext] ISR cache read error:", isrReadError);
+	}
+	return null;
+}
+async function readAppPageFallbackShellCacheResponse(options) {
+	const isrKey = options.isrHtmlKey(options.fallbackPathname);
+	try {
+		const cached = await options.isrGet(isrKey);
+		const cachedValue = getCachedAppPageValue(cached);
+		if (!cachedValue) {
+			options.isrDebug?.("MISS (fallback shell)", options.fallbackPathname);
+			return null;
+		}
+		if (isAppPprDynamicFallbackShellHtml(cachedValue.html)) {
+			options.isrDebug?.("MISS (dynamic fallback shell requires resume)", options.fallbackPathname);
+			return null;
+		}
+		return await serveAppPageCachedHtml({
+			cached,
+			cachedValue,
+			clearRequestContext: options.clearRequestContext,
+			emptyDebugMessage: "MISS (empty fallback shell)",
+			expireSeconds: options.expireSeconds,
+			isEdgeRuntime: options.isEdgeRuntime,
+			isrDebug: options.isrDebug,
+			middlewareHeaders: options.middlewareHeaders,
+			middlewareStatus: options.middlewareStatus,
+			pathname: options.fallbackPathname,
+			revalidateSeconds: options.revalidateSeconds,
+			scheduleRegeneration() {},
+			stateDebugLabel: "fallback shell"
+		}, (value) => ({
+			...value,
+			html: options.rewriteHtml(value.html)
+		}));
+	} catch (isrReadError) {
+		options.isrDebug?.("MISS (fallback shell read error)", options.fallbackPathname);
+		console.error("[vinext] ISR fallback shell cache read error:", isrReadError);
+		return null;
+	}
+}
+//#endregion
+export { buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, readAppPageFallbackShellCacheResponse, scheduleAppPageRscCacheWrite };

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

@@ -0,0 +1,223 @@
+import { ClassificationReason } from "../build/layout-classification-types.js";
+import { CachedAppPageValue } from "../shims/cache-handler.js";
+import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
+import { AppOutgoingElements } from "./app-elements-wire.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
+import { AppPageFontPreload, 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 { 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";
+
+//#region src/server/app-page-dispatch.d.ts
+type AppPageParams = Record<string, string | string[]>;
+type AppPageElement = ReactNode | Readonly<Record<string, ReactNode>>;
+type AppPageRenderableElement = ReactNode | AppOutgoingElements;
+type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
+type AppPageDebugLogger = (event: string, detail: string) => void;
+type AppPageCacheSetter = (key: string, data: CachedAppPageValue, revalidateSeconds: number, tags: string[], expireSeconds?: number) => Promise<void>;
+type AppPageCacheGetter = (key: string) => Promise<ISRCacheEntry | null>;
+type AppPageBackgroundRegenerationErrorContext = {
+  routerKind: "App Router";
+  routePath: string;
+  routeType: "render";
+};
+type AppPageBackgroundRegenerator = (key: string, renderFn: () => Promise<void>, errorContext?: AppPageBackgroundRegenerationErrorContext) => void;
+type AppPageDispatchIntercept<TPage = unknown> = {
+  interceptLayouts?: readonly unknown[] | null;
+  matchedParams: AppPageParams;
+  page: TPage;
+  slotId?: string | null;
+  slotKey: string;
+  sourceRouteIndex: number;
+  sourcePageSegments?: readonly string[] | null;
+};
+type AppPageDispatchInterceptOptions<TPage = unknown> = {
+  interceptionContext: string | null;
+  interceptLayouts?: readonly unknown[] | null;
+  interceptPage: TPage;
+  interceptParams: AppPageParams;
+  interceptSlotId?: string | null;
+  interceptSlotKey: string;
+  interceptSourceMatchedUrl?: string | null;
+  interceptSourcePageSegments?: readonly string[] | null;
+};
+type AppPageModule = {
+  default?: unknown;
+  dynamic?: unknown;
+  revalidate?: unknown;
+};
+type AppPageDispatchSlot = {
+  default?: AppPageModule | null;
+  page?: AppPageModule | null;
+  slotPatternParts?: readonly string[] | null;
+  slotParamNames?: readonly string[] | null;
+};
+type AppPageDispatchRoute = {
+  __buildTimeClassifications?: LayoutClassificationOptions["buildTimeClassifications"];
+  __buildTimeReasons?: LayoutClassificationOptions["buildTimeReasons"];
+  error?: AppPageModule | null;
+  errors?: readonly (AppPageModule | null | undefined)[];
+  forbidden?: AppPageModule | null;
+  forbiddens?: readonly (AppPageModule | null | undefined)[];
+  isDynamic: boolean;
+  layouts: readonly AppPageModule[];
+  layoutTreePositions?: readonly number[];
+  loading?: AppPageModule | null;
+  notFound?: AppPageModule | null;
+  notFounds?: readonly (AppPageModule | null | undefined)[];
+  params: readonly string[];
+  pattern: string;
+  routeSegments: readonly string[];
+  slots?: Readonly<Record<string, AppPageDispatchSlot>>;
+  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;
+  /**
+   * Allow-list of OpenTelemetry propagation keys (from
+   * `experimental.clientTraceMetadata`) to surface as `<meta>` tags in the
+   * SSR head. Undefined or empty disables emission entirely.
+   */
+  clientTraceMetadata?: readonly string[];
+  /**
+   * Maximum total length (in characters) of the preload `Link` header emitted
+   * during SSR. `0` disables emission. From `reactMaxHeadersLength` in
+   * `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>;
+  clientReuseManifest?: ClientReuseManifestParseResult;
+  cleanPathname: string;
+  displayPathname?: string;
+  clearRequestContext: () => void;
+  createRscOnErrorHandler: (pathname: string, routePath: string) => AppPageBoundaryOnError;
+  debugClassification?: (layoutId: string, reason: ClassificationReason) => void;
+  draftModeSecret: string;
+  dynamicConfig?: string;
+  dynamicStaleTimeSeconds?: number;
+  dynamicParamsConfig?: boolean;
+  /**
+   * Hydrate a source route's lazy page/route-handler modules before reading
+   * `route.page` (e.g. for fetch-cache-mode resolution) on intercept and ISR
+   * revalidation targets obtained via `getSourceRoute`. Idempotent.
+   */
+  ensureRouteLoaded?: (route: TRoute) => unknown;
+  fetchCache?: FetchCacheMode | null;
+  findIntercept: (pathname: string) => AppPageDispatchIntercept | null;
+  formState?: ReactFormState | null;
+  actionError?: unknown;
+  actionFailed?: boolean;
+  generateStaticParams?: ValidateAppPageDynamicParamsOptions["generateStaticParams"];
+  getFontLinks: () => string[];
+  getFontPreloads: () => AppPageFontPreload[];
+  getFontStyles: () => string[];
+  getNavigationContext: () => NavigationContext | null;
+  getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
+  hasGenerateStaticParams: boolean;
+  hasCustomGlobalError?: boolean;
+  hasPageDefaultExport: boolean;
+  hasPageModule: boolean;
+  handlerStart: number;
+  htmlLimitedBots?: string;
+  interceptionContext: string | null;
+  isEdgeRuntime?: boolean;
+  isProgressiveActionRender?: boolean;
+  isProduction: boolean;
+  isRscRequest: boolean;
+  isrDebug?: AppPageDebugLogger;
+  isrGet: AppPageCacheGetter;
+  isrHtmlKey: (pathname: string) => string;
+  isrRscKey: (pathname: string, mountedSlotsHeader?: string | null, renderMode?: AppRscRenderMode, interceptionContext?: string | null) => string;
+  isrSet: AppPageCacheSetter;
+  loadSsrHandler: () => Promise<AppPageSsrHandler>;
+  middlewareContext: AppPageMiddlewareContext;
+  mountedSlotsHeader?: string | null;
+  params: AppPageParams;
+  pprFallbackCacheShells?: readonly AppPagePprFallbackCacheShell[] | null;
+  pprFallbackShell?: {
+    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
+   * (evicted, stale-empty, cold start, read error), the fallback shell must
+   * NOT be served — the route is a valid generated route whose cache merely
+   * has a transient gap. Falls through to a fresh render instead.
+   */
+  renderedConcreteUrlPaths?: ReadonlySet<string>;
+  skipStaticParamsValidation?: boolean;
+  staticParamsValidationParams?: AppPageParams;
+  rootParams?: RootParams;
+  probeLayoutAt: (layoutIndex: number, layoutParamAccess?: AppLayoutParamAccessTracker) => unknown;
+  probePage: () => unknown;
+  expireSeconds?: number;
+  renderErrorBoundaryPage: (error: unknown) => Promise<Response | null>;
+  renderHttpAccessFallbackPage: (statusCode: number, opts: {
+    boundaryComponent?: unknown;
+    boundaryModule?: AppPageModule | null;
+    layouts?: readonly AppPageModule[];
+    matchedParams: AppPageParams;
+  }, middlewareContext: AppPageMiddlewareContext | null) => Promise<Response | null>;
+  renderToReadableStream: (element: AppPageRenderableElement, options: {
+    onError: AppPageBoundaryOnError;
+    signal?: AbortSignal;
+  }) => ReadableStream<Uint8Array>;
+  prerenderToReadableStream?: (element: AppPageRenderableElement, options: {
+    onError: AppPageBoundaryOnError;
+    signal?: AbortSignal;
+  }) => Promise<{
+    prelude: ReadableStream<Uint8Array>;
+  }>;
+  request: Request;
+  revalidateSeconds: number | null;
+  resolveRouteFetchCacheMode?: (route: TRoute) => FetchCacheMode | null;
+  resolveRouteDynamicConfig?: (route: TRoute) => string | null | undefined;
+  rootForbiddenModule?: AppPageModule | null;
+  rootNotFoundModule?: AppPageModule | null;
+  rootUnauthorizedModule?: AppPageModule | null;
+  route: TRoute;
+  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
+  scheduleBackgroundRegeneration: AppPageBackgroundRegenerator;
+  scriptNonce?: string;
+  searchParams: URLSearchParams;
+  setNavigationContext: (context: {
+    params: AppPageParams;
+    pathname: string;
+    searchParams: URLSearchParams;
+  }) => 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 { AppPageBoundaryOnError, AppPageDispatchRoute, AppPagePprRuntime, AppPagePprState, AppPageRenderableElement, DispatchAppPageOptions, dispatchAppPage, hasSearchParams, shouldReadAppPageCache };