@qzsy/vinext 0.1.7

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

@@ -0,0 +1,328 @@
+import { addBasePathToPathname } from "../utils/base-path.js";
+import { VINEXT_RSC_REDIRECT_HEADER } from "./headers.js";
+import { runWithConnectionProbe } from "../shims/headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { applyEdgeRuntimeHeader } from "./app-page-response.js";
+import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
+import { renderSsrErrorMetaTags } from "./app-ssr-error-meta.js";
+import { isPromiseLike } from "../utils/promise.js";
+//#region src/server/app-page-execution.ts
+/**
+* Builds the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest that
+* Next.js encodes on `redirect()` / `permanentRedirect()` throws. Used when
+* we synthesize a flight payload for an RSC navigation: the digest must
+* round-trip through the client's `RedirectErrorBoundary` so the same
+* `getURLFromRedirectError` / `getRedirectTypeFromError` helpers decode it.
+*
+* The URL is included verbatim, not encoded — Next.js's `getRedirectError`
+* sets `digest = ${CODE};${type};${url};${status};` with the raw URL, and the
+* client decodes via `error.digest.split(';').slice(2, -2).join(';')`. We
+* default `type=replace` because `redirect()` is replace-style outside of
+* server actions, matching Next.js's `getRedirectError` default.
+*
+* Reference:
+*   `.nextjs-ref/packages/next/src/client/components/redirect.ts:20-23`
+*   `.nextjs-ref/packages/next/src/client/components/redirect-error.ts`
+*/
+function formatNextRedirectDigest(options) {
+	return `NEXT_REDIRECT;replace;${options.url};${options.statusCode};`;
+}
+/**
+* Marker we tag onto a thrown redirect/notFound error when it originates from
+* `generateMetadata()` (vs. a server component itself). Metadata resolution is
+* suspended/streamed in Next.js, so a redirect from metadata is not emitted as
+* a plain HTTP-level 307. Instead the transport depends on the request:
+*   - RSC navigation requests (`Rsc: 1`) ride inside the flight payload with a
+*     200 status; the client router decodes the redirect digest.
+*   - Streaming-capable document requests get a 200 HTML response carrying a
+*     refresh meta tag (the streamed document can't switch to a 307 after the
+*     head has flushed).
+*   - html-limited bots (which Next.js serves a blocking, non-streamed
+*     response) get the HTTP-level 307.
+* Page-level redirect()s, by contrast, still produce a 307 for SSR document
+* requests.
+*
+* See Next.js test:
+*   test/e2e/app-dir/metadata-streaming/metadata-streaming.test.ts
+*/
+const APP_PAGE_METADATA_ERROR_MARKER = Symbol.for("vinext.appPage.metadataError");
+function tagAppPageMetadataError(error) {
+	if (error && typeof error === "object") try {
+		Object.defineProperty(error, APP_PAGE_METADATA_ERROR_MARKER, {
+			value: true,
+			enumerable: false,
+			configurable: true,
+			writable: false
+		});
+	} catch {}
+	return error;
+}
+function getAppPageStatusText(statusCode) {
+	return statusCode === 403 ? "Forbidden" : statusCode === 401 ? "Unauthorized" : "Not Found";
+}
+function mergeAppPageSpecialErrorHeaders(response, middlewareContext) {
+	const headers = new Headers(response.headers);
+	mergeMiddlewareResponseHeaders(headers, middlewareContext?.headers ?? null);
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+function resolveAppPageSpecialError(error) {
+	if (!(error && typeof error === "object" && "digest" in error)) return null;
+	const digest = String(error.digest);
+	const fromMetadata = error[APP_PAGE_METADATA_ERROR_MARKER] === true;
+	const redirect = parseNextRedirectDigest(digest);
+	if (redirect) return {
+		kind: "redirect",
+		location: redirect.url,
+		statusCode: redirect.status,
+		...fromMetadata ? { fromMetadata: true } : {}
+	};
+	const httpError = parseNextHttpErrorDigest(digest);
+	if (httpError) return {
+		kind: "http-access-fallback",
+		statusCode: httpError.status,
+		...fromMetadata ? { fromMetadata: true } : {}
+	};
+	return null;
+}
+/**
+* Resolves a redirect() target against the request URL and prepends the
+* configured basePath when the target is an app-internal absolute path.
+*
+* Mirrors Next.js's `addPathPrefix(getURLFromRedirectError(err), basePath)`
+* in `app-render.tsx`: a `redirect("/about")` call from a page mounted at
+* `/blog` (basePath) produces `Location: /blog/about`.
+*
+* Skips prefixing when:
+*  - basePath is unset / empty
+*  - the target is a full URL pointing at a different origin (external redirect)
+*  - the target already starts with the basePath (caller did the work themselves)
+*/
+function applyAppPageRedirectBasePath(location, requestUrl, basePath) {
+	const resolved = new URL(location, requestUrl);
+	const requestOrigin = new URL(requestUrl).origin;
+	if (!basePath || resolved.origin !== requestOrigin) return resolved.toString();
+	resolved.pathname = addBasePathToPathname(resolved.pathname, basePath);
+	return resolved.toString();
+}
+/**
+* Returns a path-relative form (`/foo?bar`) of an absolute URL when it shares
+* the request's origin; otherwise returns the URL verbatim. Used so the digest
+* we embed in the flight payload matches Next.js's convention — the digest
+* stores the path the developer passed to `redirect("/about")`, not a
+* fully-qualified URL like `https://example.com/about`.
+*/
+function sameOriginPathOrAbsolute(location, requestUrl) {
+	try {
+		const resolved = new URL(location, requestUrl);
+		const requestOrigin = new URL(requestUrl).origin;
+		if (resolved.origin !== requestOrigin) return resolved.toString();
+		return `${resolved.pathname}${resolved.search}${resolved.hash}`;
+	} catch {
+		return location;
+	}
+}
+function buildMetadataRedirectHtmlResponse(options) {
+	const headers = new Headers({ "Content-Type": "text/html; charset=utf-8" });
+	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
+	mergeMiddlewareResponseHeaders(headers, options.middlewareContext?.headers ?? null);
+	const pendingCookies = options.getAndClearPendingCookies?.() ?? [];
+	for (const cookie of pendingCookies) headers.append("Set-Cookie", cookie);
+	const errorMetaTags = renderSsrErrorMetaTags([{ digest: options.digest }]);
+	return new Response(`<!DOCTYPE html><html><head>${errorMetaTags}</head><body></body></html>`, {
+		headers,
+		status: 200
+	});
+}
+async function buildAppPageSpecialErrorResponse(options) {
+	if (options.specialError.kind === "redirect") {
+		options.clearRequestContext();
+		const prefixedLocation = applyAppPageRedirectBasePath(options.specialError.location, options.request.url, options.basePath);
+		const digestUrl = sameOriginPathOrAbsolute(prefixedLocation, options.request.url);
+		const digest = formatNextRedirectDigest({
+			url: digestUrl,
+			statusCode: options.specialError.statusCode
+		});
+		if (options.specialError.fromMetadata === true && !options.isRscRequest && options.serveStreamingMetadata !== false) return buildMetadataRedirectHtmlResponse({
+			digest,
+			getAndClearPendingCookies: options.getAndClearPendingCookies,
+			isEdgeRuntime: options.isEdgeRuntime,
+			middlewareContext: options.middlewareContext
+		});
+		if (Boolean(options.buildRscRedirectFlightStream) && options.isRscRequest && options.buildRscRedirectFlightStream) {
+			const stream = options.buildRscRedirectFlightStream({ digest });
+			const headers = new Headers({
+				"Content-Type": VINEXT_RSC_CONTENT_TYPE,
+				[VINEXT_RSC_REDIRECT_HEADER]: digestUrl
+			});
+			applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
+			applyRscCompatibilityIdHeader(headers);
+			mergeMiddlewareResponseHeaders(headers, options.middlewareContext?.headers ?? null);
+			const pendingCookies = options.getAndClearPendingCookies?.() ?? [];
+			for (const cookie of pendingCookies) headers.append("Set-Cookie", cookie);
+			return new Response(stream, {
+				headers,
+				status: 200
+			});
+		}
+		const location = options.isRscRequest ? await createRscRedirectLocation(prefixedLocation, options.request) : prefixedLocation;
+		const headers = new Headers({ Location: location });
+		mergeMiddlewareResponseHeaders(headers, options.middlewareContext?.headers ?? null);
+		const pendingCookies = options.getAndClearPendingCookies?.() ?? [];
+		for (const cookie of pendingCookies) headers.append("Set-Cookie", cookie);
+		return new Response(null, {
+			headers,
+			status: options.specialError.statusCode
+		});
+	}
+	if (options.renderFallbackPage) {
+		const fallbackResponse = await options.renderFallbackPage(options.specialError.statusCode);
+		if (fallbackResponse) return mergeAppPageSpecialErrorHeaders(options.specialError.fromMetadata === true && options.serveStreamingMetadata !== false ? new Response(fallbackResponse.body, {
+			headers: fallbackResponse.headers,
+			status: 200,
+			statusText: fallbackResponse.statusText
+		}) : fallbackResponse, options.middlewareContext);
+	}
+	options.clearRequestContext();
+	const responseStatus = options.specialError.fromMetadata === true && options.serveStreamingMetadata !== false ? 200 : options.specialError.statusCode;
+	return mergeAppPageSpecialErrorHeaders(new Response(getAppPageStatusText(options.specialError.statusCode), { status: responseStatus }), options.middlewareContext);
+}
+/** See `LayoutFlags` type docblock in app-elements.ts for lifecycle. */
+async function probeAppPageLayouts(options) {
+	const layoutFlags = {};
+	const cls = options.classification ?? null;
+	return {
+		response: await options.runWithSuppressedHookWarning(async () => {
+			for (let layoutIndex = options.layoutCount - 1; layoutIndex >= 0; layoutIndex--) {
+				const buildTimeResult = cls?.buildTimeClassifications?.get(layoutIndex);
+				if (cls && buildTimeResult) {
+					const layoutId = cls.getLayoutId(layoutIndex);
+					layoutFlags[layoutId] = buildTimeResult === "static" ? "s" : "d";
+					const errorResponse = await probeLayoutForErrors(options, layoutIndex);
+					if (errorResponse) return errorResponse;
+					const observationDynamic = cls.isLayoutObservationDynamic?.(layoutId) === true;
+					layoutFlags[layoutId] = buildTimeResult === "dynamic" || observationDynamic ? "d" : "s";
+					if (cls.debugClassification) if (observationDynamic && buildTimeResult === "static") cls.debugClassification(layoutId, {
+						layer: "runtime-probe",
+						outcome: "dynamic"
+					});
+					else cls.debugClassification(layoutId, cls.buildTimeReasons?.get(layoutIndex) ?? { layer: "no-classifier" });
+					continue;
+				}
+				if (cls) {
+					const layoutId = cls.getLayoutId(layoutIndex);
+					try {
+						const { dynamicDetected } = await cls.runWithIsolatedDynamicScope(async () => {
+							const outcome = await runWithConnectionProbe(() => options.probeLayoutAt(layoutIndex));
+							return outcome.completed ? outcome.result : null;
+						});
+						const observationDynamic = cls.isLayoutObservationDynamic?.(layoutId) === true;
+						const layoutDynamic = dynamicDetected || observationDynamic;
+						layoutFlags[layoutId] = layoutDynamic ? "d" : "s";
+						if (cls.debugClassification) cls.debugClassification(layoutId, {
+							layer: "runtime-probe",
+							outcome: layoutDynamic ? "dynamic" : "static"
+						});
+					} catch (error) {
+						layoutFlags[layoutId] = "d";
+						if (cls.debugClassification) cls.debugClassification(layoutId, {
+							layer: "runtime-probe",
+							outcome: "dynamic",
+							error: error instanceof Error ? error.message : String(error)
+						});
+						const errorResponse = await options.onLayoutError(error, layoutIndex);
+						if (errorResponse) return errorResponse;
+					}
+					continue;
+				}
+				const errorResponse = await probeLayoutForErrors(options, layoutIndex);
+				if (errorResponse) return errorResponse;
+			}
+			return null;
+		}),
+		layoutFlags
+	};
+}
+async function probeLayoutForErrors(options, layoutIndex) {
+	const outcome = await runWithConnectionProbe(async () => {
+		try {
+			const layoutResult = options.probeLayoutAt(layoutIndex);
+			if (isPromiseLike(layoutResult)) await layoutResult;
+		} catch (error) {
+			return options.onLayoutError(error, layoutIndex);
+		}
+		return null;
+	});
+	return outcome.completed ? outcome.result : null;
+}
+async function probeAppPageComponent(options) {
+	return options.runWithSuppressedHookWarning(async () => {
+		const outcome = await runWithConnectionProbe(async () => {
+			try {
+				const pageResult = options.probePage();
+				if (isPromiseLike(pageResult)) if (options.awaitAsyncResult) await pageResult;
+				else Promise.resolve(pageResult).catch(() => {});
+			} catch (error) {
+				return options.onError(error);
+			}
+			return null;
+		});
+		return outcome.completed ? outcome.result : null;
+	});
+}
+async function probeAppPageThrownError(options) {
+	return options.runWithSuppressedHookWarning(async () => {
+		const outcome = await runWithConnectionProbe(async () => {
+			try {
+				const pageResult = options.probePage();
+				if (isPromiseLike(pageResult)) await pageResult;
+			} catch (error) {
+				return {
+					error,
+					thrown: true
+				};
+			}
+			return {
+				error: null,
+				thrown: false
+			};
+		});
+		return outcome.completed && outcome.result.thrown ? outcome.result.error : null;
+	});
+}
+async function readAppPageBinaryStream(stream) {
+	const reader = stream.getReader();
+	const chunks = [];
+	let totalLength = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+		totalLength += value.byteLength;
+	}
+	const buffer = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		buffer.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return buffer.buffer;
+}
+function teeAppPageRscStreamForCapture(stream, shouldCapture) {
+	if (!shouldCapture) return { ssrStream: stream };
+	const [ssrStream, sideStream] = stream.tee();
+	return {
+		ssrStream,
+		sideStream
+	};
+}
+function buildAppPageFontLinkHeader(preloads) {
+	if (!preloads || preloads.length === 0) return "";
+	return preloads.map((preload) => `<${preload.href}>; rel=preload; as=font; type=${preload.type}; crossorigin`).join(", ");
+}
+//#endregion
+export { buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, probeAppPageThrownError, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };

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

@@ -0,0 +1,65 @@
+import { MetadataFileRoute } from "./metadata-routes.js";
+import { AppPageParams } from "./app-page-boundary.js";
+import { Metadata, Viewport } from "../shims/metadata.js";
+import { applyFileBasedMetadata } from "./file-based-metadata.js";
+
+//#region src/server/app-page-head.d.ts
+type AppPageSearchParams = Record<string, string | string[]>;
+type AppPageHeadModule = Record<string, unknown>;
+type ApplyAppPageFileBasedMetadata = typeof applyFileBasedMetadata;
+type AppPageHeadParallelRoute<TModule extends AppPageHeadModule = AppPageHeadModule> = {
+  layoutModule?: TModule | null;
+  layoutModules?: readonly (TModule | null | undefined)[] | null;
+  pageModule?: TModule | null;
+  params?: AppPageParams | null;
+  routeSegments?: readonly string[] | null;
+};
+type AppPageHeadSlot<TModule extends AppPageHeadModule = AppPageHeadModule> = {
+  layout?: TModule | null;
+  page?: TModule | null;
+};
+type ResolveActiveParallelRouteHeadInputsOptions<TModule extends AppPageHeadModule = AppPageHeadModule> = {
+  interceptLayouts?: readonly (TModule | null | undefined)[] | null;
+  interceptPage?: TModule | null;
+  interceptParams?: AppPageParams | null;
+  interceptSlotKey?: string | null;
+  params: AppPageParams;
+  routeSegments: readonly string[];
+  slots?: Record<string, AppPageHeadSlot<TModule>> | null;
+};
+type ResolveAppPageHeadOptions<TModule extends AppPageHeadModule = AppPageHeadModule> = {
+  applyFileBasedMetadata?: ApplyAppPageFileBasedMetadata;
+  /**
+   * Configured next.config `basePath`. Threaded into `applyFileBasedMetadata`
+   * so file-based metadata route URLs (icon, opengraph-image, manifest, ...)
+   * emitted in <head> are prefixed with the basePath. Empty string when no
+   * basePath is configured.
+   */
+  basePath?: string;
+  fallbackOnFileMetadataError?: boolean;
+  layoutModules: readonly (TModule | null | undefined)[];
+  layoutTreePositions?: readonly number[] | null;
+  metadataRoutes: readonly MetadataFileRoute[];
+  pageModule?: TModule | null;
+  parallelRoutes?: readonly AppPageHeadParallelRoute<TModule>[] | null;
+  params: AppPageParams;
+  routePath: string;
+  routeSegments?: readonly string[] | null;
+  searchParams?: URLSearchParams | null;
+};
+type ResolveAppPageHeadResult = {
+  hasDynamicMetadata: boolean;
+  hasSearchParams: boolean;
+  metadata: Metadata | null;
+  pageSearchParams: AppPageSearchParams;
+  viewport: Viewport;
+};
+type AppPageSearchParamsCollection = {
+  hasSearchParams: boolean;
+  pageSearchParams: AppPageSearchParams;
+};
+declare function resolveActiveParallelRouteHeadInputs<TModule extends AppPageHeadModule>(options: ResolveActiveParallelRouteHeadInputsOptions<TModule>): AppPageHeadParallelRoute<TModule>[];
+declare function collectAppPageSearchParams(searchParams: URLSearchParams | null | undefined): AppPageSearchParamsCollection;
+declare function resolveAppPageHead<TModule extends AppPageHeadModule>(options: ResolveAppPageHeadOptions<TModule>): Promise<ResolveAppPageHeadResult>;
+//#endregion
+export { AppPageSearchParams, ApplyAppPageFileBasedMetadata, collectAppPageSearchParams, resolveActiveParallelRouteHeadInputs, resolveAppPageHead };

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

@@ -0,0 +1,228 @@
+import { runWithFetchDedupe } from "../shims/fetch-cache.js";
+import { mergeMetadataEntries, mergeViewport, postProcessMetadata, resolveModuleMetadata as resolveModuleMetadata$1, resolveModuleViewport } from "../shims/metadata.js";
+import { resolveAppPageSegmentParams } from "./app-page-params.js";
+import { tagAppPageMetadataError } from "./app-page-execution.js";
+//#region src/server/app-page-head.ts
+/**
+* Wrapped {@link _resolveModuleMetadata} that tags any thrown error with the
+* `APP_PAGE_METADATA_ERROR_MARKER` symbol. The marker lets downstream special-
+* error handling distinguish a `generateMetadata()` redirect/notFound from a
+* page-component redirect/notFound, which matters because metadata is
+* suspended/streamed in Next.js. Its redirects no longer become a plain
+* HTTP 307: RSC navigation rides inside the flight payload (200), streaming
+* document SSR gets an HTML refresh meta tag (200), and html-limited bots
+* get a blocking 307 — whereas page redirects still emit a 307 for SSR.
+* See https://github.com/cloudflare/vinext/issues/1347
+* and Next.js test/e2e/app-dir/metadata-streaming.
+*/
+async function resolveModuleMetadata(...args) {
+	try {
+		return await resolveModuleMetadata$1(...args);
+	} catch (error) {
+		throw tagAppPageMetadataError(error);
+	}
+}
+function resolveActiveParallelRouteHeadInputs(options) {
+	return Object.entries(options.slots ?? {}).map(([slotKey, slot]) => {
+		if (options.interceptSlotKey === slotKey && options.interceptPage) return {
+			layoutModules: options.interceptLayouts ?? [],
+			pageModule: options.interceptPage,
+			params: options.interceptParams ?? options.params,
+			routeSegments: options.routeSegments
+		};
+		return {
+			layoutModules: slot.layout ? [slot.layout] : [],
+			pageModule: slot.page,
+			params: options.params,
+			routeSegments: options.routeSegments
+		};
+	});
+}
+function isPresent(value) {
+	return value !== null && value !== void 0;
+}
+function hasGenerateMetadata(module) {
+	return typeof module?.generateMetadata === "function";
+}
+function collectAppPageSearchParams(searchParams) {
+	const pageSearchParams = Object.create(null);
+	let hasSearchParams = false;
+	searchParams?.forEach((value, key) => {
+		hasSearchParams = true;
+		const currentValue = pageSearchParams[key];
+		if (Array.isArray(currentValue)) {
+			pageSearchParams[key] = [...currentValue, value];
+			return;
+		}
+		if (currentValue !== void 0) {
+			pageSearchParams[key] = [currentValue, value];
+			return;
+		}
+		pageSearchParams[key] = value;
+	});
+	return {
+		hasSearchParams,
+		pageSearchParams
+	};
+}
+function createMetadataSources(metadataResults, routeSegments, layoutTreePositions, pageMetadata, includePageSource) {
+	const metadataSources = metadataResults.map((metadata, index) => ({
+		routeSegments: routeSegments.slice(0, layoutTreePositions[index] ?? 0),
+		metadata
+	}));
+	if (includePageSource) metadataSources.push({
+		routeSegments,
+		metadata: pageMetadata
+	});
+	return metadataSources;
+}
+function createLayoutInputs(layoutModules, layoutTreePositions) {
+	const layoutInputs = [];
+	for (let index = 0; index < layoutModules.length; index++) {
+		const layoutModule = layoutModules[index];
+		if (!isPresent(layoutModule)) continue;
+		layoutInputs.push({
+			module: layoutModule,
+			treePosition: layoutTreePositions[index] ?? 0
+		});
+	}
+	return layoutInputs;
+}
+async function resolveLayoutMetadata(layoutInputs, params, routeSegments) {
+	const layoutMetadataPromises = [];
+	let accumulatedMetadata = Promise.resolve({});
+	for (const layoutInput of layoutInputs) {
+		const parentForLayout = accumulatedMetadata;
+		const layoutParams = resolveAppPageSegmentParams(routeSegments, layoutInput.treePosition, params);
+		const metadataPromise = resolveModuleMetadata(layoutInput.module, layoutParams, void 0, parentForLayout);
+		layoutMetadataPromises.push(metadataPromise);
+		metadataPromise.catch(() => null);
+		accumulatedMetadata = metadataPromise.then(async (metadataResult) => {
+			if (metadataResult) return mergeMetadataEntries([{ metadata: await parentForLayout }, { metadata: metadataResult }]);
+			return parentForLayout;
+		});
+		accumulatedMetadata.catch(() => null);
+	}
+	return Promise.all(layoutMetadataPromises);
+}
+async function resolveLayoutViewport(layoutInputs, params, routeSegments) {
+	return Promise.all(layoutInputs.map((layoutInput) => {
+		const layoutParams = resolveAppPageSegmentParams(routeSegments, layoutInput.treePosition, params);
+		return resolveModuleViewport(layoutInput.module, layoutParams);
+	}));
+}
+async function resolveParallelRouteHead(parallelRoute, fallbackParams, fallbackRouteSegments, pageSearchParams, parent) {
+	const params = parallelRoute.params ?? fallbackParams;
+	const routeSegments = parallelRoute.routeSegments ?? fallbackRouteSegments;
+	const metadataResults = [];
+	const viewportResults = [];
+	const metadataSources = [];
+	let accumulatedMetadata = parent;
+	const layoutModules = [...parallelRoute.layoutModules ?? [], parallelRoute.layoutModule].filter(isPresent);
+	const hasDynamicMetadata = layoutModules.some(hasGenerateMetadata) || hasGenerateMetadata(parallelRoute.pageModule);
+	const layoutViewportPromises = layoutModules.map((layoutModule) => resolveModuleViewport(layoutModule, params));
+	const pageViewportPromise = parallelRoute.pageModule ? resolveModuleViewport(parallelRoute.pageModule, params) : Promise.resolve(null);
+	for (const layoutViewportPromise of layoutViewportPromises) layoutViewportPromise.catch(() => null);
+	pageViewportPromise.catch(() => null);
+	for (const layoutModule of layoutModules) {
+		const layoutMetadata = await resolveModuleMetadata(layoutModule, params, void 0, accumulatedMetadata);
+		metadataResults.push(layoutMetadata);
+		metadataSources.push({
+			metadata: layoutMetadata,
+			routeSegments
+		});
+		if (layoutMetadata) {
+			accumulatedMetadata = accumulatedMetadata.then(async (parentMetadata) => mergeMetadataEntries([{ metadata: parentMetadata }, { metadata: layoutMetadata }]));
+			accumulatedMetadata.catch(() => null);
+		}
+	}
+	if (parallelRoute.pageModule) {
+		const pageMetadata = await resolveModuleMetadata(parallelRoute.pageModule, params, pageSearchParams, accumulatedMetadata);
+		metadataResults.push(pageMetadata);
+		metadataSources.push({
+			metadata: pageMetadata,
+			routeSegments
+		});
+	}
+	viewportResults.push(...await Promise.all(layoutViewportPromises));
+	const pageViewport = await pageViewportPromise;
+	if (parallelRoute.pageModule) viewportResults.push(pageViewport);
+	return {
+		hasDynamicMetadata,
+		metadataResults,
+		metadataSources,
+		viewportResults
+	};
+}
+async function resolveAppPageHead(options) {
+	return await runWithFetchDedupe(() => resolveAppPageHeadInner(options));
+}
+async function resolveAppPageHeadInner(options) {
+	const routeSegments = options.routeSegments ?? [];
+	const layoutTreePositions = options.layoutTreePositions ?? [];
+	const layoutInputs = createLayoutInputs(options.layoutModules, layoutTreePositions);
+	const layoutSourcePositions = layoutInputs.map((input) => input.treePosition);
+	const primaryHasDynamicMetadata = layoutInputs.some((input) => hasGenerateMetadata(input.module)) || hasGenerateMetadata(options.pageModule);
+	const { hasSearchParams, pageSearchParams } = collectAppPageSearchParams(options.searchParams);
+	const layoutMetadataPromise = resolveLayoutMetadata(layoutInputs, options.params, routeSegments);
+	const layoutViewportPromise = resolveLayoutViewport(layoutInputs, options.params, routeSegments);
+	const layoutMetadataResultsForParent = layoutMetadataPromise.then((metadataResults) => metadataResults.filter(isPresent));
+	layoutMetadataResultsForParent.catch(() => null);
+	const pageParentPromise = layoutMetadataResultsForParent.then((metadataResults) => metadataResults.length > 0 ? mergeMetadataEntries(metadataResults.map((metadata) => ({ metadata }))) : {});
+	pageParentPromise.catch(() => null);
+	const pageMetadataPromise = options.pageModule ? resolveModuleMetadata(options.pageModule, options.params, pageSearchParams, pageParentPromise) : Promise.resolve(null);
+	const pageViewportPromise = options.pageModule ? resolveModuleViewport(options.pageModule, options.params) : Promise.resolve(null);
+	const parallelRouteHeadPromise = Promise.all((options.parallelRoutes ?? []).map((parallelRoute) => resolveParallelRouteHead(parallelRoute, options.params, routeSegments, pageSearchParams, pageParentPromise)));
+	const [layoutMetadataResults, layoutViewportResults, pageMetadata, pageViewport, parallelRouteHeads] = await Promise.all([
+		layoutMetadataPromise,
+		layoutViewportPromise,
+		pageMetadataPromise,
+		pageViewportPromise,
+		parallelRouteHeadPromise
+	]);
+	const parallelMetadataResults = parallelRouteHeads.flatMap((head) => head.metadataResults);
+	const parallelViewportResults = parallelRouteHeads.flatMap((head) => head.viewportResults);
+	const parallelMetadataSources = parallelRouteHeads.flatMap((head) => head.metadataSources);
+	const hasDynamicMetadata = primaryHasDynamicMetadata || parallelRouteHeads.some((head) => head.hasDynamicMetadata);
+	const primaryPageHasTitle = pageMetadata != null && pageMetadata.title !== void 0;
+	const metadataEntries = [
+		...layoutMetadataResults.filter(isPresent).map((metadata) => ({ metadata })),
+		...pageMetadata ? [{
+			isPage: true,
+			metadata: pageMetadata
+		}] : [],
+		...parallelMetadataResults.filter(isPresent).map((metadata) => ({
+			contributesTitle: !primaryPageHasTitle,
+			metadata
+		}))
+	];
+	const viewportList = [
+		...layoutViewportResults.filter(isPresent),
+		...pageViewport ? [pageViewport] : [],
+		...parallelViewportResults.filter(isPresent)
+	];
+	const resolvedMetadataBase = metadataEntries.length > 0 ? mergeMetadataEntries(metadataEntries) : null;
+	const metadataSources = createMetadataSources(layoutMetadataResults, routeSegments, layoutSourcePositions, pageMetadata, Boolean(options.pageModule));
+	metadataSources.push(...parallelMetadataSources);
+	let metadata = resolvedMetadataBase;
+	if (options.applyFileBasedMetadata && options.metadataRoutes.length > 0) try {
+		metadata = await options.applyFileBasedMetadata(resolvedMetadataBase, options.routePath, options.params, options.metadataRoutes, {
+			routeSegments,
+			metadataSources,
+			basePath: options.basePath ?? ""
+		});
+	} catch (error) {
+		if (!options.fallbackOnFileMetadataError) throw error;
+		console.error(`[vinext] File-based metadata resolution failed while rendering error boundary for ${options.routePath}:`, error);
+	}
+	if (metadata) metadata = postProcessMetadata(metadata);
+	return {
+		hasDynamicMetadata,
+		hasSearchParams,
+		metadata,
+		pageSearchParams,
+		viewport: mergeViewport(viewportList)
+	};
+}
+//#endregion
+export { collectAppPageSearchParams, resolveActiveParallelRouteHeadInputs, resolveAppPageHead };

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

@@ -0,0 +1,15 @@
+//#region src/server/app-page-method.d.ts
+type AppPageMethodPolicyOptions = {
+  dynamicConfig?: string;
+  hasGenerateStaticParams: boolean;
+  isDynamicRoute: boolean;
+  revalidateSeconds: number | null;
+};
+type ResolveAppPageMethodResponseOptions = {
+  middlewareHeaders?: Headers | null;
+  request: Pick<Request, "headers" | "method">;
+} & AppPageMethodPolicyOptions;
+declare function isStaticOrSsgAppPageCandidate(options: AppPageMethodPolicyOptions): boolean;
+declare function resolveAppPageMethodResponse(options: ResolveAppPageMethodResponseOptions): Response | null;
+//#endregion
+export { isStaticOrSsgAppPageCandidate, resolveAppPageMethodResponse };

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

@@ -0,0 +1,25 @@
+import { methodNotAllowedResponse } from "./http-error-responses.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+//#region src/server/app-page-method.ts
+function isNonGetOrHead(method) {
+	const normalizedMethod = method.toUpperCase();
+	return normalizedMethod !== "GET" && normalizedMethod !== "HEAD";
+}
+function isStaticOrSsgAppPageCandidate(options) {
+	if (options.dynamicConfig === "force-dynamic" || options.revalidateSeconds === 0) return false;
+	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") return true;
+	if (options.revalidateSeconds !== null && options.revalidateSeconds > 0) return true;
+	if (options.hasGenerateStaticParams) return true;
+	return !options.isDynamicRoute;
+}
+function resolveAppPageMethodResponse(options) {
+	if (!isNonGetOrHead(options.request.method)) return null;
+	if (isPossibleAppRouteActionRequest(options.request)) return null;
+	if (!isStaticOrSsgAppPageCandidate(options)) return null;
+	const headers = new Headers();
+	mergeMiddlewareResponseHeaders(headers, options.middlewareHeaders ?? null);
+	return methodNotAllowedResponse("GET, HEAD", { headers });
+}
+//#endregion
+export { isStaticOrSsgAppPageCandidate, resolveAppPageMethodResponse };

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

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