vinext 1.3.0 → 1.4.0

package/dist/server/app-page-http-access-fallback-metadata.d.ts

@@ -1,6 +1,6 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppPageParams } from "./app-page-boundary.js";
-import { Metadata, ResolvedViewport } from "../shims/metadata.js";
+import { Metadata, ResolvedViewport, Viewport } from "../shims/metadata.js";
 import { ActiveParallelRouteHeadInput, AppPageHeadModule, ApplyAppPageFileBasedMetadata, OrderedAppPageMetadataSource } from "./app-page-head.js";
 //#region src/server/app-page-http-access-fallback-metadata.d.ts
 type HttpAccessFallbackMetadataPlanOptions<TModule extends AppPageHeadModule = AppPageHeadModule> = {
@@ -26,5 +26,52 @@ type ResolveHttpAccessFallbackMetadataOptions<TModule extends AppPageHeadModule
 };
 export declare function createHttpAccessFallbackMetadataPlan<TModule extends AppPageHeadModule>(options: HttpAccessFallbackMetadataPlanOptions<TModule>): OrderedAppPageMetadataSource<TModule>[];
 export declare function resolveHttpAccessFallbackMetadata<TModule extends AppPageHeadModule>(options: ResolveHttpAccessFallbackMetadataOptions<TModule>): Promise<Metadata | null>;
+type RouteNotFoundHeadPlanRoute<TModule extends AppPageHeadModule> = {
+  layouts?: readonly (TModule | null | undefined)[];
+  layoutTreePositions?: readonly number[] | null;
+  notFound?: TModule | null;
+  notFounds?: readonly (TModule | null | undefined)[] | null;
+  notFoundTreePosition?: number | null;
+  routeSegments?: readonly string[] | null;
+  segmentNotFoundTreePositions?: readonly number[] | null;
+};
+/**
+ * The not-found head a route's own head falls back to. Like Next.js's
+ * metadata tree, every HTTP access signal from generateMetadata() or
+ * generateViewport() resolves through the not-found convention, whichever
+ * signal the route's render threw.
+ */
+export declare function createRouteNotFoundHeadPlanOptions<TModule extends AppPageHeadModule>(options: {
+  parallelBranches: readonly ActiveParallelRouteHeadInput<TModule>[];
+  params: AppPageParams;
+  primaryParallelBranch: ActiveParallelRouteHeadInput<TModule> | null;
+  rootNotFoundModule?: TModule | null;
+  route: RouteNotFoundHeadPlanRoute<TModule>;
+}): HttpAccessFallbackMetadataPlanOptions<TModule>;
+/**
+ * Settle each branch of a route's head on its own, as Next.js's MetadataTree
+ * and ViewportTree do: an HTTP access signal from generateMetadata() keeps the
+ * resolved viewport and resolves the metadata through the not-found
+ * convention, and the same holds the other way round. Any other error leaves
+ * that branch empty; the route's render reports it where it renders.
+ *
+ * A `dynamic = "error"` access error leaves its branch empty too, but
+ * `accessError` keeps it, whether the route's head or the not-found head it
+ * recovers through threw it: Next.js fails such a render even where its
+ * metadata trees drop the error, so a fallback without the route's outlet
+ * rethrows it.
+ */
+export declare function recoverAppPageRouteHead<TModule extends AppPageHeadModule>(head: {
+  metadata: Promise<Metadata | null>;
+  viewport: Promise<ResolvedViewport>;
+}, options: Omit<ResolveHttpAccessFallbackMetadataOptions<TModule>, keyof HttpAccessFallbackMetadataPlanOptions<TModule>> & {
+  resolvePlanOptions: () => HttpAccessFallbackMetadataPlanOptions<TModule>;
+}): {
+  accessError: Promise<Error | null>;
+  metadata: Promise<Metadata | null>;
+  /** `null` when the branch failed: like Next.js's, the head then has no viewport tags. */
+  viewport: Promise<Viewport | null>;
+};
 export declare function resolveHttpAccessFallbackViewport<TModule extends AppPageHeadModule>(options: HttpAccessFallbackMetadataPlanOptions<TModule>): Promise<ResolvedViewport>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-page-http-access-fallback-metadata.js

@@ -1,7 +1,10 @@
+import { isStaticGenerationAccessError } from "../shims/internal/headers-state.js";
 import { mergeViewport, resolveModuleViewport } from "../shims/metadata.js";
-import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { resolveAppPageSpecialError } from "./app-page-execution.js";
 import { createAppMetadataModuleRoute } from "./app-metadata-tracing.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { resolveOrderedAppPageMetadata } from "./app-page-head.js";
+import { resolveAppPageParentHttpAccessBoundary } from "./app-page-boundary.js";
 //#region src/server/app-page-http-access-fallback-metadata.ts
 function isPresent(value) {
 	return value !== null && value !== void 0;
@@ -106,6 +109,78 @@ function resolveHttpAccessFallbackMetadata(options) {
 		sources: createHttpAccessFallbackMetadataPlan(options)
 	});
 }
+/**
+* The not-found head a route's own head falls back to. Like Next.js's
+* metadata tree, every HTTP access signal from generateMetadata() or
+* generateViewport() resolves through the not-found convention, whichever
+* signal the route's render threw.
+*/
+function createRouteNotFoundHeadPlanOptions(options) {
+	const { route } = options;
+	const routeSegments = route.routeSegments ?? [];
+	const layoutModules = route.layouts ?? [];
+	let boundaryModule = route.notFound ?? null;
+	let boundaryTreePosition = boundaryModule ? route.notFoundTreePosition : null;
+	if (!boundaryModule) {
+		const parentBoundary = resolveAppPageParentHttpAccessBoundary({
+			layoutIndex: layoutModules.length,
+			rootNotFoundModule: route.segmentNotFoundTreePositions ? null : options.rootNotFoundModule,
+			routeNotFoundModules: route.notFounds,
+			statusCode: 404
+		});
+		boundaryModule = parentBoundary.module;
+		boundaryTreePosition = parentBoundary.layoutIndex === null ? null : route.layoutTreePositions?.[parentBoundary.layoutIndex];
+	}
+	return {
+		boundaryModule,
+		boundaryParams: boundaryModule && boundaryTreePosition != null ? resolveAppPageSegmentParams(routeSegments, boundaryTreePosition, options.params) : {},
+		boundaryRouteSegments: routeSegments.slice(0, boundaryTreePosition ?? 0),
+		errorConvention: "not-found",
+		layoutModules,
+		layoutTreePositions: route.layoutTreePositions,
+		parallelBranches: options.parallelBranches,
+		params: options.params,
+		primaryParallelBranch: options.primaryParallelBranch,
+		routeSegments: route.routeSegments ?? null
+	};
+}
+/**
+* Settle each branch of a route's head on its own, as Next.js's MetadataTree
+* and ViewportTree do: an HTTP access signal from generateMetadata() keeps the
+* resolved viewport and resolves the metadata through the not-found
+* convention, and the same holds the other way round. Any other error leaves
+* that branch empty; the route's render reports it where it renders.
+*
+* A `dynamic = "error"` access error leaves its branch empty too, but
+* `accessError` keeps it, whether the route's head or the not-found head it
+* recovers through threw it: Next.js fails such a render even where its
+* metadata trees drop the error, so a fallback without the route's outlet
+* rethrows it.
+*/
+function recoverAppPageRouteHead(head, options) {
+	const { resolvePlanOptions, ...metadataOptions } = options;
+	const settleEmpty = (error, empty) => ({
+		accessError: isStaticGenerationAccessError(error) ? error : null,
+		value: empty
+	});
+	const recover = (branch, recoverBranch, empty) => branch.then((value) => ({
+		accessError: null,
+		value
+	}), (error) => resolveAppPageSpecialError(error)?.kind === "http-access-fallback" ? recoverBranch().then((value) => ({
+		accessError: null,
+		value
+	}), (recoveryError) => settleEmpty(recoveryError, empty)) : settleEmpty(error, empty));
+	const metadata = recover(head.metadata, () => resolveHttpAccessFallbackMetadata({
+		...metadataOptions,
+		...resolvePlanOptions()
+	}), null);
+	const viewport = recover(head.viewport, () => resolveHttpAccessFallbackViewport(resolvePlanOptions()), null);
+	return {
+		accessError: Promise.all([metadata, viewport]).then(([metadataResult, viewportResult]) => metadataResult.accessError ?? viewportResult.accessError),
+		metadata: metadata.then((result) => result.value),
+		viewport: viewport.then((result) => result.value)
+	};
+}
 async function resolveHttpAccessFallbackViewport(options) {
 	let accumulatedViewport = Promise.resolve(mergeViewport([]));
 	for (const source of createHttpAccessFallbackPlan(options, "snapshot")) {
@@ -118,4 +193,4 @@ async function resolveHttpAccessFallbackViewport(options) {
 	return accumulatedViewport;
 }
 //#endregion
-export { createHttpAccessFallbackMetadataPlan, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport };
+export { createHttpAccessFallbackMetadataPlan, createRouteNotFoundHeadPlanOptions, recoverAppPageRouteHead, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport };

package/dist/server/app-page-layout-gate.d.ts

@@ -0,0 +1,35 @@
+//#region src/server/app-page-layout-gate.d.ts
+/**
+ * Holds an RSC response until the layouts above the route's first loading
+ * boundary have rendered, so that a layout's redirect(), notFound(),
+ * forbidden() or unauthorized() still answers the request: a redirect through
+ * the `X-Vinext-Rsc-Redirect` side channel, and the others with their
+ * boundary's status. The layouts render once, in the render itself. A
+ * signal from a component a layout renders streams in the payload, as in
+ * Next.js.
+ */
+export type AppPageLayoutGate = {
+  /** Holds the response until the layout with `layoutId` has rendered. */
+  hold(layoutId: string, layoutIndex: number): void;
+  /** Reports how the layout with `layoutId` rendered. */
+  settle(layoutId: string, failure?: {
+    error: unknown;
+  }): void;
+  /**
+   * The outermost held layout that threw, once every held layout `isRendered`
+   * includes has rendered, or null. An error elsewhere in the render doesn't
+   * stop the wait, as Flight goes on to render the other entries, but the
+   * render ending does: `ended` settles when its stream closes or errors.
+   */
+  wait(isRendered: (layoutId: string) => boolean, ended: Promise<unknown>): Promise<AppPageLayoutGateFailure | null>;
+};
+type AppPageLayoutGateFailure = {
+  error: unknown;
+  layoutIndex: number;
+};
+export declare function createAppPageLayoutGate(): AppPageLayoutGate;
+export declare function registerAppPageLayoutGate(elements: object, gate: AppPageLayoutGate): void;
+/** The gate of the layouts in `element`, an App Router elements record. */
+export declare function getAppPageLayoutGate(element: unknown): AppPageLayoutGate | null;
+//#endregion
+export {};

package/dist/server/app-page-layout-gate.js

@@ -0,0 +1,50 @@
+//#region src/server/app-page-layout-gate.ts
+function createAppPageLayoutGate() {
+	const held = /* @__PURE__ */ new Map();
+	const settled = /* @__PURE__ */ new Set();
+	let failure = null;
+	let ended = false;
+	let check = null;
+	return {
+		hold(layoutId, layoutIndex) {
+			held.set(layoutId, layoutIndex);
+		},
+		settle(layoutId, layoutFailure) {
+			const layoutIndex = held.get(layoutId);
+			if (layoutIndex === void 0 || settled.has(layoutId)) return;
+			settled.add(layoutId);
+			if (layoutFailure) {
+				if (failure === null || layoutIndex < failure.layoutIndex) failure = {
+					error: layoutFailure.error,
+					layoutIndex
+				};
+			}
+			check?.();
+		},
+		wait(isRendered, renderEnded) {
+			return new Promise((resolve) => {
+				check = () => {
+					for (const layoutId of held.keys()) if (!ended && !settled.has(layoutId) && isRendered(layoutId)) return;
+					check = null;
+					resolve(failure);
+				};
+				const end = () => {
+					ended = true;
+					check?.();
+				};
+				renderEnded.then(end, end);
+				check();
+			});
+		}
+	};
+}
+const appPageLayoutGates = /* @__PURE__ */ new WeakMap();
+function registerAppPageLayoutGate(elements, gate) {
+	appPageLayoutGates.set(elements, gate);
+}
+/** The gate of the layouts in `element`, an App Router elements record. */
+function getAppPageLayoutGate(element) {
+	return typeof element === "object" && element !== null ? appPageLayoutGates.get(element) ?? null : null;
+}
+//#endregion
+export { createAppPageLayoutGate, getAppPageLayoutGate, registerAppPageLayoutGate };

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

@@ -6,4 +6,5 @@ type ResolveAppPageMethodResponseOptions = {
   request: Pick<Request, "headers" | "method">;
 };
 export declare function resolveAppPageMethodResponse(options: ResolveAppPageMethodResponseOptions): Response | null;
-//#endregion
+//#endregion
+export {};

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

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

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

@@ -8,19 +8,6 @@ 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 ?? [];
@@ -43,4 +30,4 @@ function resolveAppPageBranchParams(branchSegments, treePosition, matchedParams,
 	return scopedParams;
 }
 //#endregion
-export { getAppPageSegmentParamName, resolveAppPageBranchParams, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams };
+export { getAppPageSegmentParamName, resolveAppPageBranchParams, resolveAppPageSegmentParams };

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

@@ -1,30 +1,13 @@
-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.
+ * Invokes the server components a layout renders, so the error-path layout
+ * probe sees an HTTP access fallback thrown below the layout's own function
+ * body. The real RSC render remains authoritative.
  */
 export declare function probeReactServerSubtree(node: unknown, options?: ProbeReactServerSubtreeOptions): Promise<void>;
-type ProbeAppPageBeforeRenderResult = {
-  response: Response | null;
-  layoutFlags: LayoutFlags;
-};
-type ProbeAppPageBeforeRenderOptions = {
-  skipProbes?: boolean;
-  layoutCount: number;
-  probeLayoutAt: (layoutIndex: number) => unknown;
-  renderLayoutSpecialError: (specialError: AppPageSpecialError, layoutIndex: number) => 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;
-};
-export declare function probeAppPageBeforeRender(options: ProbeAppPageBeforeRenderOptions): Promise<ProbeAppPageBeforeRenderResult>;
-//#endregion
+//#endregion
+export {};

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

@@ -1,5 +1,4 @@
 import { isPromiseLike } from "../utils/promise.js";
-import { probeAppPageLayouts } from "./app-page-execution.js";
 import { Fragment, isValidElement } from "react";
 //#region src/server/app-page-probe.ts
 const DEFAULT_SUBTREE_PROBE_MAX_DEPTH = 32;
@@ -63,10 +62,9 @@ async function resolveReactLazyType(lazyType) {
 	}
 }
 /**
-* 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.
+* Invokes the server components a layout renders, so the error-path layout
+* probe sees an HTTP access fallback thrown below the layout's own function
+* body. The real RSC render remains authoritative.
 */
 async function probeReactServerSubtree(node, options = {}) {
 	const maxDepth = options.maxDepth ?? DEFAULT_SUBTREE_PROBE_MAX_DEPTH;
@@ -118,36 +116,5 @@ async function probeReactServerSubtree(node, options = {}) {
 	};
 	await visit(node, 0);
 }
-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
-		};
-	}
-	return {
-		response: null,
-		layoutFlags
-	};
-}
 //#endregion
-export { probeAppPageBeforeRender, probeReactServerSubtree };
+export { probeReactServerSubtree };

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

@@ -19,4 +19,5 @@ export type AppPageRenderIdentity = {
   targetMatchedPathname: string;
 };
 export declare function createAppPageRenderIdentity(input: AppPageRenderIdentityInput): AppPageRenderIdentity;
-//#endregion
+//#endregion
+export {};

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

@@ -1,12 +1,10 @@
-import { ClientReuseManifestParseResult, ClientReuseManifestSkipDisposition } from "./client-reuse-manifest.js";
 import { AppOutgoingElements } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation.js";
-import { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions } from "./app-page-execution.js";
+import { AppPageFontPreload, AppPageSpecialError } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
-import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppRenderErrorContextOverrides } from "./app-rsc-error-handler.js";
@@ -29,6 +27,11 @@ type AppPageSpecialErrorRenderOptions = {
    * candidate's render it must not carry the request's query.
    */
   isCacheCandidate?: boolean;
+  /**
+   * The page's own document, in which parallel slot boundaries caught the
+   * error, to send in place of a fallback page.
+   */
+  caughtDocument?: Response;
 };
 type PreparedAppPageElement = {
   element: AppPageRenderableElement;
@@ -105,7 +108,6 @@ type RenderAppPageLifecycleOptionsBase = {
   isrSet: AppPageCacheSetter;
   interceptionContext?: string | null;
   interceptionId?: string | null;
-  layoutCount: number;
   loadSsrHandler: () => Promise<AppPageSsrHandler>;
   middlewareContext: AppPageMiddlewareContext;
   navigationParams: Record<string, unknown>;
@@ -115,12 +117,10 @@ type RenderAppPageLifecycleOptionsBase = {
   abortPprFallbackShell?: () => void;
   rootParams?: RootParams;
   peekRenderObservationState?: () => AppPageRenderObservationState;
-  probeLayoutAt: (layoutIndex: number) => unknown;
   expireSeconds?: number;
   formState?: ReactFormState | null;
   revalidateSeconds: number | null;
   renderErrorBoundaryResponse: (error: unknown, errorOrigin: "rsc" | "ssr") => Promise<Response | null>;
-  renderLayoutSpecialError: (specialError: AppPageSpecialError, layoutIndex: number) => Promise<Response>;
   renderPageSpecialError: (specialError: AppPageSpecialError, renderOptions?: AppPageSpecialErrorRenderOptions) => Promise<Response>;
   renderToReadableStream: (element: ReactNode | AppOutgoingElements, options: {
     onError: AppPageBoundaryOnError;
@@ -133,16 +133,11 @@ type RenderAppPageLifecycleOptionsBase = {
     prelude: ReadableStream<Uint8Array>;
   }>;
   routePattern: string;
-  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
   scriptNonce?: string;
-  clientReuseManifest?: ClientReuseManifestParseResult;
-  skipDisposition?: ClientReuseManifestSkipDisposition;
   mountedSlotsHeader?: string | null;
   renderedPathAndSearch?: string | null;
   renderMode?: AppRscRenderMode;
   waitUntil?: (promise: Promise<void>) => void;
-  layoutParamAccess?: AppLayoutParamAccessTracker;
-  classification?: LayoutClassificationOptions | null;
 };
 type RenderAppPageLifecycleOptions = RenderAppPageLifecycleOptionsBase & ({
   element: AppPageRenderableElement;
@@ -158,6 +153,7 @@ type RenderAppPageLifecycleOptions = RenderAppPageLifecycleOptionsBase & ({
  * its response policy, such as error boundaries and special errors, get the
  * same header as the normal render.
  */
-export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, probeCacheLife?: AppPageRequestCacheLife | null): Response;
+export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, requestCacheLife?: AppPageRequestCacheLife | null): Response;
 export declare function renderAppPageLifecycle(options: RenderAppPageLifecycleOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};