@qzsy/vinext 0.1.7

package/dist/server/app-optimistic-routing.js

@@ -0,0 +1,227 @@
+import { buildParams, decodeMatchedParams, splitPathnameForRouteMatch } from "../routing/utils.js";
+import { stripBasePath } from "../utils/base-path.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
+import { isUnknownRecord } from "../utils/record.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { Suspense, createElement, isValidElement } from "react";
+//#region src/server/app-optimistic-routing.ts
+const routeTrieCache = /* @__PURE__ */ new WeakMap();
+const OPTIMISTIC_ROUTE_SEGMENT_SUSPENSE_TRIGGER = new Promise(() => {});
+function getOptimisticRouteTemplateKey(options) {
+	return `${options.routeId}\0${options.interceptionContext ?? ""}\0${options.mountedSlotsHeader ?? ""}`;
+}
+function getOptimisticPrefetchSourceKey(options) {
+	return `${options.cacheKey}\0${options.interceptionContext ?? ""}\0${options.mountedSlotsHeader ?? ""}`;
+}
+function createNode() {
+	return {
+		catchAllChild: null,
+		dynamicChild: null,
+		optionalCatchAllChild: null,
+		route: null,
+		staticChildren: /* @__PURE__ */ new Map()
+	};
+}
+function buildRouteTrie(routeManifest) {
+	const root = createNode();
+	for (const route of routeManifest.segmentGraph.routes.values()) {
+		let node = root;
+		const parts = route.patternParts;
+		if (parts.length === 0) {
+			node.route ??= route;
+			continue;
+		}
+		for (const [index, part] of parts.entries()) {
+			const isTerminal = index === parts.length - 1;
+			if (part.startsWith(":") && part.endsWith("+")) {
+				if (isTerminal && node.catchAllChild === null) node.catchAllChild = {
+					paramName: part.slice(1, -1),
+					route
+				};
+				break;
+			}
+			if (part.startsWith(":") && part.endsWith("*")) {
+				if (isTerminal && node.optionalCatchAllChild === null) node.optionalCatchAllChild = {
+					paramName: part.slice(1, -1),
+					route
+				};
+				break;
+			}
+			if (part.startsWith(":")) {
+				const paramName = part.slice(1);
+				if (node.dynamicChild === null) node.dynamicChild = {
+					node: createNode(),
+					paramName
+				};
+				else if (node.dynamicChild.paramName !== paramName && import.meta.env.DEV) console.warn(`[vinext] Optimistic route trie found conflicting dynamic segments at the same level: :${node.dynamicChild.paramName} vs ${part}`);
+				node = node.dynamicChild.node;
+				if (isTerminal) node.route ??= route;
+				continue;
+			}
+			let staticChild = node.staticChildren.get(part);
+			if (staticChild === void 0) {
+				staticChild = createNode();
+				node.staticChildren.set(part, staticChild);
+			}
+			node = staticChild;
+			if (isTerminal) node.route ??= route;
+		}
+	}
+	return root;
+}
+function getRouteTrie(routeManifest) {
+	const existing = routeTrieCache.get(routeManifest);
+	if (existing) return existing;
+	const trie = buildRouteTrie(routeManifest);
+	routeTrieCache.set(routeManifest, trie);
+	return trie;
+}
+function matchNode(node, urlParts, index, entries) {
+	if (index === urlParts.length) {
+		if (node.route !== null) return {
+			route: node.route,
+			params: buildParams(entries)
+		};
+		if (node.optionalCatchAllChild !== null) return {
+			route: node.optionalCatchAllChild.route,
+			params: buildParams(entries)
+		};
+		return null;
+	}
+	const segment = urlParts[index];
+	const staticChild = node.staticChildren.get(segment);
+	if (staticChild !== void 0) return matchNode(staticChild, urlParts, index + 1, entries);
+	if (node.dynamicChild !== null) {
+		entries.push([node.dynamicChild.paramName, segment]);
+		const match = matchNode(node.dynamicChild.node, urlParts, index + 1, entries);
+		if (match !== null) return match;
+		entries.pop();
+	}
+	if (node.catchAllChild !== null) {
+		const params = buildParams(entries);
+		params[node.catchAllChild.paramName] = urlParts.slice(index);
+		return {
+			route: node.catchAllChild.route,
+			params
+		};
+	}
+	if (node.optionalCatchAllChild !== null) {
+		const params = buildParams(entries);
+		params[node.optionalCatchAllChild.paramName] = urlParts.slice(index);
+		return {
+			route: node.optionalCatchAllChild.route,
+			params
+		};
+	}
+	return null;
+}
+function hrefToRouteParts(href, basePath) {
+	let url;
+	try {
+		url = new URL(href, "https://vinext.local");
+	} catch {
+		return null;
+	}
+	stripRscCacheBustingSearchParam(url);
+	const appPathname = stripBasePath(stripRscSuffix(url.pathname), basePath);
+	return splitPathnameForRouteMatch(appPathname === "" ? "/" : appPathname);
+}
+function matchOptimisticRouteManifestRoute(options) {
+	const urlParts = hrefToRouteParts(options.href, options.basePath);
+	if (urlParts === null) return null;
+	const match = matchNode(getRouteTrie(options.routeManifest), urlParts, 0, []);
+	if (match === null) return null;
+	decodeMatchedParams(match.params);
+	return match;
+}
+function mergeParams(target, source) {
+	for (const [key, value] of Object.entries(source)) target[key] = value;
+}
+function resolveOptimisticNavigationParams(options) {
+	const navigationParams = { ...options.match.params };
+	for (const binding of options.routeManifest.segmentGraph.slotBindings.values()) {
+		if (binding.routeId !== options.match.route.id || binding.state !== "active") continue;
+		const patternParts = binding.slotPatternParts;
+		if (!patternParts) continue;
+		const matched = matchRoutePattern(options.urlParts, patternParts);
+		if (matched) mergeParams(navigationParams, matched);
+	}
+	return navigationParams;
+}
+function elementHasSuspenseFallback(value, depth = 0) {
+	if (depth > 100) return false;
+	if (Array.isArray(value)) return value.some((entry) => elementHasSuspenseFallback(entry, depth + 1));
+	if (!isValidElement(value)) return false;
+	const props = Reflect.get(value, "props");
+	if (value.type === Suspense && isUnknownRecord(props)) {
+		const fallback = Reflect.get(props, "fallback");
+		if (fallback !== null && fallback !== void 0) return true;
+	}
+	if (!isUnknownRecord(props)) return false;
+	return elementHasSuspenseFallback(Reflect.get(props, "children"), depth + 1);
+}
+function getPageElementIds(elements) {
+	return Object.keys(elements).filter((key) => AppElementsWire.parseElementKey(key)?.kind === "page").sort();
+}
+function OptimisticRouteSegment() {
+	throw OPTIMISTIC_ROUTE_SEGMENT_SUSPENSE_TRIGGER;
+}
+function createOptimisticRouteTemplate(options) {
+	const match = matchOptimisticRouteManifestRoute({
+		basePath: options.basePath,
+		href: options.href,
+		routeManifest: options.routeManifest
+	});
+	if (match === null || !options.allowLoadingShell && !match.route.isDynamic) return null;
+	if (options.interceptionContext !== null) return null;
+	const metadata = AppElementsWire.readMetadata(options.elements);
+	if (metadata.interception !== null || metadata.interceptionContext !== null) return null;
+	const routeElement = options.elements[metadata.routeId];
+	if (!options.allowLoadingShell && !elementHasSuspenseFallback(routeElement)) return null;
+	if (options.allowLoadingShell && options.elements["__prefetchLoadingShell"] !== "LoadingBoundary") return null;
+	if (options.allowLoadingShell && (routeElement === void 0 || routeElement === null)) return null;
+	const pageElementIds = getPageElementIds(options.elements);
+	if (pageElementIds.length === 0) return null;
+	return {
+		elements: options.elements,
+		mountedSlotsHeader: options.mountedSlotsHeader,
+		pageElementIds,
+		routeId: match.route.id
+	};
+}
+function createOptimisticRouteElements(template) {
+	const elements = { ...template.elements };
+	for (const pageElementId of template.pageElementIds) elements[pageElementId] = createElement(OptimisticRouteSegment);
+	return elements;
+}
+function resolveOptimisticNavigationPayload(options) {
+	if (options.interceptionContext !== null) return null;
+	const urlParts = hrefToRouteParts(options.href, options.basePath);
+	if (urlParts === null) return null;
+	const match = matchOptimisticRouteManifestRoute({
+		basePath: options.basePath,
+		href: options.href,
+		routeManifest: options.routeManifest
+	});
+	if (match === null) return null;
+	const template = options.templates.get(getOptimisticRouteTemplateKey({
+		interceptionContext: options.interceptionContext,
+		mountedSlotsHeader: options.mountedSlotsHeader,
+		routeId: match.route.id
+	}));
+	if (template === void 0) return null;
+	if (template.mountedSlotsHeader !== options.mountedSlotsHeader) return null;
+	return {
+		elements: createOptimisticRouteElements(template),
+		params: resolveOptimisticNavigationParams({
+			match,
+			routeManifest: options.routeManifest,
+			urlParts
+		}),
+		template
+	};
+}
+//#endregion
+export { createOptimisticRouteElements, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationPayload };

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

@@ -0,0 +1,85 @@
+import { MetadataFileRoute } from "./metadata-routes.js";
+import { AppElements } from "./app-elements-wire.js";
+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";
+
+//#region src/server/app-page-boundary-render.d.ts
+type AppPageComponent = ComponentType<any>;
+type AppPageModule = Record<string, unknown> & {
+  default?: AppPageComponent | null | undefined;
+};
+type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
+type AppPageBoundaryRoute<TModule extends AppPageModule = AppPageModule> = {
+  error?: TModule | null;
+  errorPaths?: readonly TModule[] | null;
+  errors?: readonly (TModule | null | undefined)[] | null;
+  forbidden?: TModule | null;
+  layoutTreePositions?: readonly number[] | null;
+  layouts?: readonly (TModule | null | undefined)[];
+  notFound?: TModule | null;
+  params?: AppPageParams;
+  pattern?: string;
+  routeSegments?: readonly string[];
+  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;
+  getFontLinks: () => string[];
+  getFontPreloads: () => AppPageFontPreload[];
+  getFontStyles: () => string[];
+  getNavigationContext: () => NavigationContext | null;
+  globalErrorModule?: TModule | null;
+  isEdgeRuntime?: boolean;
+  isRscRequest: boolean;
+  loadSsrHandler: () => Promise<AppPageSsrHandler>;
+  makeThenableParams: (params: AppPageParams) => unknown;
+  middlewareContext: AppPageMiddlewareContext;
+  metadataRoutes: MetadataFileRoute[]; /** Configured next.config `basePath`, threaded into file-based metadata href emission. */
+  basePath?: string; /** Configured next.config `trailingSlash`, threaded into canonical URL rendering. */
+  trailingSlash?: boolean;
+  renderToReadableStream: (element: ReactNode | AppElements, options: {
+    onError: AppPageBoundaryOnError;
+  }) => ReadableStream<Uint8Array>;
+  requestUrl: string;
+  resolveChildSegments: (routeSegments: readonly string[], treePosition: number, params: AppPageParams) => string[];
+  rootLayouts: readonly (TModule | null | undefined)[];
+  scriptNonce?: string;
+  sourcePageSegments?: readonly string[] | null;
+};
+type RenderAppPageHttpAccessFallbackOptions<TModule extends AppPageModule = AppPageModule> = {
+  boundaryComponent?: AppPageComponent | null;
+  boundaryModule?: TModule | null;
+  layoutModules?: readonly (TModule | null | undefined)[] | null;
+  matchedParams: AppPageParams;
+  rootForbiddenModule?: TModule | null;
+  rootNotFoundModule?: TModule | null;
+  rootUnauthorizedModule?: TModule | null;
+  route?: AppPageBoundaryRoute<TModule> | null;
+  /**
+   * When true, the resolved boundary is rendered without wrapping it in the
+   * route's layouts. Used by `global-not-found.tsx`, which provides its own
+   * `<html>`/`<body>` and intentionally replaces the root layout.
+   * Mirrors Next.js's `createNotFoundLoaderTree` behavior for `hasGlobalNotFound`.
+   * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/app-render.tsx#L495-L520
+   */
+  skipLayoutWrapping?: boolean;
+  statusCode: number;
+} & AppPageBoundaryRenderCommonOptions<TModule>;
+type RenderAppPageErrorBoundaryOptions<TModule extends AppPageModule = AppPageModule> = {
+  error: unknown;
+  matchedParams?: AppPageParams | null;
+  route?: AppPageBoundaryRoute<TModule> | null;
+  sanitizeErrorForClient: (error: Error) => Error;
+} & AppPageBoundaryRenderCommonOptions<TModule>;
+declare function renderAppPageHttpAccessFallback<TModule extends AppPageModule>(options: RenderAppPageHttpAccessFallbackOptions<TModule>): Promise<Response | null>;
+declare function renderAppPageErrorBoundary<TModule extends AppPageModule>(options: RenderAppPageErrorBoundaryOptions<TModule>): Promise<Response | null>;
+//#endregion
+export { AppPageBoundaryRoute, renderAppPageErrorBoundary, renderAppPageHttpAccessFallback };

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

@@ -0,0 +1,305 @@
+import { NEVER_CACHE_CONTROL } from "./cache-control.js";
+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 { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
+import { MetadataHead, ViewportHead } from "../shims/metadata.js";
+import { resolveAppPageSpecialError } from "./app-page-execution.js";
+import { resolveAppPageHead } from "./app-page-head.js";
+import { createAppPageLayoutEntries, createAppPageSourcePage } from "./app-page-route-wiring.js";
+import { buildClientHookErrorMessage } from "../shims/client-hook-error.js";
+import { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryModule, wrapAppPageBoundaryElement } from "./app-page-boundary.js";
+import { createAppPageFontData, renderAppPageHtmlResponse } from "./app-page-stream.js";
+import { Fragment, createElement } from "react";
+//#region src/server/app-page-boundary-render.ts
+const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
+function getDefaultExport(module) {
+	return module?.default ?? null;
+}
+function wrapRenderedBoundaryElement(options) {
+	return wrapAppPageBoundaryElement({
+		element: options.element,
+		getDefaultExport,
+		globalErrorComponent: getDefaultExport(options.globalErrorModule),
+		includeGlobalErrorBoundary: options.includeGlobalErrorBoundary,
+		isRscRequest: options.isRscRequest,
+		layoutModules: options.layoutModules,
+		layoutTreePositions: options.layoutTreePositions,
+		makeThenableParams: options.makeThenableParams,
+		matchedParams: options.matchedParams,
+		renderErrorBoundary(GlobalErrorComponent, children) {
+			return createElement(GlobalErrorBoundary, {
+				fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+				children: createElement(ErrorBoundary, {
+					fallback: GlobalErrorComponent,
+					children
+				})
+			});
+		},
+		renderLayout(LayoutComponent, children, asyncParams) {
+			return createElement(LayoutComponent, {
+				children,
+				params: asyncParams
+			});
+		},
+		renderLayoutSegmentProvider(segmentMap, children) {
+			return createElement(LayoutSegmentProvider, { segmentMap }, children);
+		},
+		resolveChildSegments: options.resolveChildSegments,
+		routeSegments: options.routeSegments ?? [],
+		skipLayoutWrapping: options.skipLayoutWrapping
+	});
+}
+function createAppPageBoundaryLayoutEntries(route, layoutModules) {
+	if (!route || layoutModules.length === 0) return [];
+	return createAppPageLayoutEntries({
+		errors: route.errors,
+		layoutTreePositions: route.layoutTreePositions,
+		layouts: layoutModules,
+		notFounds: null,
+		routeSegments: route.routeSegments
+	});
+}
+function resolveHttpAccessFallbackHeadRouteSegments(route, layoutModules) {
+	if (!route?.routeSegments) return;
+	if (!route.layouts || layoutModules.length >= route.layouts.length) return route.routeSegments;
+	const lastIncludedLayoutIndex = layoutModules.length - 1;
+	if (lastIncludedLayoutIndex < 0) return [];
+	const segmentCount = route.layoutTreePositions?.[lastIncludedLayoutIndex] ?? 0;
+	return route.routeSegments.slice(0, segmentCount);
+}
+function resolveHttpAccessFallbackHeadLayoutTreePositions(route, layoutModules) {
+	if (!route?.layouts || layoutModules.length >= route.layouts.length) return route?.layoutTreePositions;
+	return route.layoutTreePositions?.slice(0, layoutModules.length);
+}
+function createAppPageBoundaryRscPayload(options) {
+	const routeId = AppElementsWire.encodeRouteId(options.pathname, null);
+	const layoutEntries = createAppPageBoundaryLayoutEntries(options.route, options.layoutModules);
+	const sourcePageSegments = options.sourcePageSegments ?? options.route?.routeSegments;
+	return {
+		...AppElementsWire.createMetadataEntries({
+			interceptionContext: null,
+			layoutIds: layoutEntries.map((entry) => entry.id),
+			rootLayoutTreePath: layoutEntries[0]?.treePath ?? null,
+			routeId,
+			sourcePage: sourcePageSegments ? createAppPageSourcePage(sourcePageSegments) : null
+		}),
+		[routeId]: options.element
+	};
+}
+async function renderAppPageBoundaryElementResponse(options) {
+	const requestUrl = new URL(options.requestUrl);
+	const pathname = requestUrl.pathname;
+	return renderAppPageBoundaryResponse({
+		async createHtmlResponse(rscStream, responseStatus) {
+			const fontData = createAppPageFontData({
+				getLinks: options.getFontLinks,
+				getPreloads: options.getFontPreloads,
+				getStyles: options.getFontStyles
+			});
+			const ssrHandler = await options.loadSsrHandler();
+			return renderAppPageHtmlResponse({
+				clearRequestContext: options.clearRequestContext,
+				fontData,
+				fontLinkHeader: options.buildFontLinkHeader(fontData.preloads),
+				isEdgeRuntime: options.isEdgeRuntime,
+				middlewareHeaders: options.middlewareContext.headers,
+				navigationContext: options.getNavigationContext() ?? {
+					pathname,
+					searchParams: requestUrl.searchParams,
+					params: options.navigationParams ?? options.route?.params ?? {}
+				},
+				rscStream,
+				scriptNonce: options.scriptNonce,
+				ssrHandler,
+				status: responseStatus,
+				initialDevServerError: options.initialDevServerError
+			});
+		},
+		createRscOnErrorHandler() {
+			return options.createRscOnErrorHandler(pathname, options.routePattern ?? pathname);
+		},
+		element: createAppPageBoundaryRscPayload({
+			element: options.element,
+			layoutModules: options.layoutModules,
+			pathname,
+			route: options.route,
+			sourcePageSegments: options.sourcePageSegments
+		}),
+		isEdgeRuntime: options.isEdgeRuntime,
+		isRscRequest: options.isRscRequest,
+		middlewareHeaders: options.middlewareContext.headers,
+		renderToReadableStream: options.renderToReadableStream,
+		status: options.status
+	});
+}
+async function renderAppPageHttpAccessFallback(options) {
+	const resolvedBoundaryModule = resolveAppPageHttpAccessBoundaryModule({
+		rootForbiddenModule: options.rootForbiddenModule,
+		rootNotFoundModule: options.rootNotFoundModule,
+		rootUnauthorizedModule: options.rootUnauthorizedModule,
+		routeForbiddenModule: options.route?.forbidden,
+		routeNotFoundModule: options.route?.notFound,
+		routeUnauthorizedModule: options.route?.unauthorized,
+		statusCode: options.statusCode
+	});
+	const boundaryModule = options.boundaryModule ?? resolvedBoundaryModule;
+	const boundaryComponent = options.boundaryComponent ?? getDefaultExport(boundaryModule);
+	if (!boundaryComponent) return null;
+	const layoutModules = options.layoutModules ?? options.route?.layouts ?? options.rootLayouts;
+	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),
+		metadataRoutes: options.metadataRoutes,
+		pageModule: boundaryModule,
+		params: options.matchedParams,
+		routePath: options.route?.pattern ?? pathname,
+		routeSegments
+	});
+	const headElements = [createElement("meta", {
+		charSet: "utf-8",
+		key: "charset"
+	}), createElement("meta", {
+		key: "robots",
+		name: "robots",
+		content: "noindex"
+	})];
+	if (metadata) headElements.push(createElement(MetadataHead, {
+		key: "metadata",
+		metadata,
+		pathname,
+		trailingSlash: options.trailingSlash
+	}));
+	headElements.push(createElement(ViewportHead, {
+		key: "viewport",
+		viewport
+	}));
+	const skipLayoutWrapping = options.skipLayoutWrapping ?? false;
+	const element = wrapRenderedBoundaryElement({
+		element: createElement(Fragment, null, ...headElements, createElement(boundaryComponent)),
+		globalErrorModule: options.globalErrorModule,
+		includeGlobalErrorBoundary: true,
+		isRscRequest: options.isRscRequest,
+		layoutModules,
+		layoutTreePositions: options.route?.layoutTreePositions,
+		makeThenableParams: options.makeThenableParams,
+		matchedParams: options.matchedParams,
+		resolveChildSegments: options.resolveChildSegments,
+		routeSegments: options.route?.routeSegments,
+		skipLayoutWrapping
+	});
+	return renderAppPageBoundaryElementResponse({
+		...options,
+		element,
+		layoutModules: skipLayoutWrapping ? [] : layoutModules,
+		navigationParams: options.matchedParams,
+		route: skipLayoutWrapping ? null : options.route,
+		routePattern: options.route?.pattern,
+		status: options.statusCode
+	});
+}
+async function renderAppPageErrorBoundary(options) {
+	const errorBoundary = resolveAppPageErrorBoundary({
+		getDefaultExport,
+		errorModules: options.route?.errorPaths,
+		globalErrorModule: options.globalErrorModule,
+		layoutErrorModules: options.route?.errors,
+		pageErrorModule: options.route?.error
+	});
+	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 matchedParams = options.matchedParams ?? options.route?.params ?? {};
+	const layoutModules = options.route?.layouts ?? options.rootLayouts;
+	const pathname = new URL(options.requestUrl).pathname;
+	const headElements = [createElement("meta", {
+		charSet: "utf-8",
+		key: "charset"
+	})];
+	if (!errorBoundary.isGlobalError) try {
+		const { metadata, viewport } = await resolveAppPageHead({
+			applyFileBasedMetadata: options.applyFileBasedMetadata,
+			basePath: options.basePath ?? "",
+			fallbackOnFileMetadataError: true,
+			layoutModules,
+			layoutTreePositions: options.route?.layoutTreePositions,
+			metadataRoutes: options.metadataRoutes,
+			params: matchedParams,
+			routePath: options.route?.pattern ?? pathname,
+			routeSegments: options.route?.routeSegments
+		});
+		if (metadata) headElements.push(createElement(MetadataHead, {
+			key: "metadata",
+			metadata,
+			pathname,
+			trailingSlash: options.trailingSlash
+		}));
+		headElements.push(createElement(ViewportHead, {
+			key: "viewport",
+			viewport
+		}));
+	} catch (error) {
+		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 });
+		return wrapRenderedBoundaryElement({
+			element: createElement(Fragment, null, ...headElements, errorBoundary.isGlobalError ? createElement(GlobalErrorBoundary, {
+				fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+				children: boundaryElement
+			}) : boundaryElement),
+			globalErrorModule: options.globalErrorModule,
+			includeGlobalErrorBoundary: !errorBoundary.isGlobalError,
+			isRscRequest: options.isRscRequest,
+			layoutModules,
+			layoutTreePositions: options.route?.layoutTreePositions,
+			makeThenableParams: options.makeThenableParams,
+			matchedParams,
+			resolveChildSegments: options.resolveChildSegments,
+			routeSegments: options.route?.routeSegments,
+			skipLayoutWrapping: errorBoundary.isGlobalError
+		});
+	};
+	const renderWith = async (BoundaryComponent) => {
+		const response = await renderAppPageBoundaryElementResponse({
+			...options,
+			element: buildElement(BoundaryComponent),
+			initialDevServerError: rawError,
+			layoutModules,
+			navigationParams: matchedParams,
+			route: options.route,
+			routePattern: options.route?.pattern,
+			status: errorBoundary.isGlobalError ? 500 : 200
+		});
+		if (errorBoundary.isGlobalError) {
+			response.headers.set("Cache-Control", NEVER_CACHE_CONTROL);
+			response.headers.delete("CDN-Cache-Control");
+			response.headers.delete("Cloudflare-CDN-Cache-Control");
+			response.headers.delete("Cache-Tag");
+		}
+		return response;
+	};
+	try {
+		return await renderWith(errorBoundary.component);
+	} catch (renderError) {
+		if (errorBoundary.isGlobalError && !isNavigationSignalError(renderError) && !resolveAppPageSpecialError(renderError)) {
+			console.error(`[vinext] global-error.tsx threw while rendering for ${options.route?.pattern ?? pathname}; falling back to the built-in default global-error:`, renderError);
+			return renderWith(DEFAULT_GLOBAL_ERROR_COMPONENT);
+		}
+		throw renderError;
+	}
+}
+const _clientHookPattern = /\b(useState|useEffect|useReducer|useRef|useContext|useLayoutEffect|useInsertionEffect|useSyncExternalStore|useTransition|useImperativeHandle|useDeferredValue|useActionState|useOptimistic|useEffectEvent)\b.*is not a function/;
+function rewriteClientHookError(error) {
+	const match = error.message.match(_clientHookPattern);
+	if (match) error.message = buildClientHookErrorMessage(`${match[1]}()`);
+}
+//#endregion
+export { renderAppPageErrorBoundary, renderAppPageHttpAccessFallback };