vinext 0.0.54 → 0.1.0

package/dist/server/pages-page-data.js

@@ -1,24 +1,61 @@
 import { normalizeStaticPathname } from "../routing/route-pattern.js";
 import { buildCacheStateHeaders } from "./cache-headers.js";
 import { buildPagesCacheValue } from "./isr-cache.js";
-import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
 import { isSerializableProps } from "./pages-serializable-props.js";
-import { buildCachedRevalidateCacheControl } from "./cache-control.js";
+import { hasPagesGetInitialProps, isResponseSent, loadPagesGetInitialProps } from "./pages-get-initial-props.js";
+import { applyCdnResponseHeaders, buildCachedRevalidateCacheControl } from "./cache-control.js";
+import { buildNextDataJsonResponse } from "./pages-data-route.js";
 import { buildPagesNextDataScript } from "./pages-page-response.js";
 //#region src/server/pages-page-data.ts
-function buildPagesNotFoundResponse() {
-	return buildDefaultPagesNotFoundResponse();
-}
 function buildPagesDataNotFoundResponse() {
 	return new Response("{}", {
 		status: 404,
 		headers: { "Content-Type": "application/json" }
 	});
 }
+function buildPagesNotFoundResult(options) {
+	if (options.isDataReq) return {
+		kind: "response",
+		response: buildPagesDataNotFoundResponse()
+	};
+	return { kind: "notFound" };
+}
 function resolvePagesRedirectStatus(redirect) {
 	return redirect.statusCode != null ? redirect.statusCode : redirect.permanent ? 308 : 307;
 }
 /**
+* Build the response for a `getServerSideProps` / `getStaticProps`
+* `{ redirect }` result.
+*
+* For an HTML page request we emit a real HTTP redirect (`Location` header) so
+* a hard navigation lands on the destination.
+*
+* For a `/_next/data/<buildId>/<page>.json` request (a client-side navigation)
+* we must NOT emit an HTTP redirect: the client's `fetch()` would transparently
+* follow it to the destination's HTML, which is not a valid data envelope and
+* would force a hard reload (and console error noise). Instead we mirror
+* Next.js and return a 200 JSON envelope carrying `__N_REDIRECT` /
+* `__N_REDIRECT_STATUS` inside `pageProps`. The client router detects these
+* markers and performs a fresh client navigation to the destination, which
+* supersedes (cancels) the in-flight navigation.
+*
+* Ported from Next.js: `packages/next/src/server/render.tsx` — the
+* `__N_REDIRECT` / `__N_REDIRECT_STATUS` props assignment for gSSP/gSP
+* redirects (search `__N_REDIRECT`), consumed in
+* `packages/next/src/shared/lib/router/router.ts` (`pageProps.__N_REDIRECT`).
+*/
+function buildPagesRedirectResponse(redirect, options) {
+	const destination = options.sanitizeDestination(redirect.destination);
+	if (options.isDataReq) return buildNextDataJsonResponse({
+		__N_REDIRECT: destination,
+		__N_REDIRECT_STATUS: resolvePagesRedirectStatus(redirect)
+	}, options.safeJsonStringify);
+	return new Response(null, {
+		status: resolvePagesRedirectStatus(redirect),
+		headers: { Location: destination }
+	});
+}
+/**
 * Compare a `getStaticPaths` entry against the actual request params.
 *
 * Handles both shapes Next.js allows:
@@ -46,12 +83,12 @@ function matchesPagesStaticPath(pathEntry, params, routeUrl) {
 function buildPagesCacheResponse(html, cacheState, fontLinkHeader, revalidateSeconds, expireSeconds, cacheControl, status) {
 	const effectiveRevalidateSeconds = cacheControl?.revalidate ?? revalidateSeconds ?? 60;
 	const effectiveExpireSeconds = cacheControl === void 0 ? void 0 : cacheControl.expire ?? expireSeconds;
-	const headers = {
+	const headers = new Headers({
 		"Content-Type": "text/html",
-		...buildCacheStateHeaders(cacheState),
-		"Cache-Control": buildCachedRevalidateCacheControl(cacheState, effectiveRevalidateSeconds, effectiveExpireSeconds)
-	};
-	if (fontLinkHeader) headers.Link = fontLinkHeader;
+		...buildCacheStateHeaders(cacheState)
+	});
+	applyCdnResponseHeaders(headers, { cacheControl: buildCachedRevalidateCacheControl(cacheState, effectiveRevalidateSeconds, effectiveExpireSeconds) });
+	if (fontLinkHeader) headers.set("Link", fontLinkHeader);
 	return new Response(html, {
 		status: status ?? 200,
 		headers
@@ -94,10 +131,7 @@ async function resolvePagesPageData(options) {
 		});
 		const fallback = pathsResult?.fallback ?? false;
 		const isValidPath = (pathsResult?.paths ?? []).some((pathEntry) => matchesPagesStaticPath(pathEntry, options.params, options.routeUrl));
-		if (fallback === false && !isValidPath) return {
-			kind: "response",
-			response: options.isDataReq ? buildPagesDataNotFoundResponse() : buildPagesNotFoundResponse()
-		};
+		if (fallback === false && !isValidPath) return buildPagesNotFoundResult(options);
 		if (fallback === true && !isValidPath && !options.isDataReq) isFallback = true;
 	}
 	let pageProps = {};
@@ -121,22 +155,16 @@ async function resolvePagesPageData(options) {
 			locales: options.i18n.locales,
 			defaultLocale: options.i18n.defaultLocale
 		});
-		if (res.headersSent) return {
+		if (isResponseSent(res)) return {
 			kind: "response",
 			response: await responsePromise
 		};
 		if (result?.props) pageProps = await Promise.resolve(result.props);
 		if (result?.redirect) return {
 			kind: "response",
-			response: new Response(null, {
-				status: resolvePagesRedirectStatus(result.redirect),
-				headers: { Location: options.sanitizeDestination(result.redirect.destination) }
-			})
-		};
-		if (result?.notFound) return {
-			kind: "response",
-			response: options.isDataReq ? buildPagesDataNotFoundResponse() : buildPagesNotFoundResponse()
+			response: buildPagesRedirectResponse(result.redirect, options)
 		};
+		if (result?.notFound) return buildPagesNotFoundResult(options);
 		if (result?.props !== void 0) isSerializableProps(options.routePattern, "getServerSideProps", pageProps);
 		gsspRes = res;
 	}
@@ -197,18 +225,34 @@ async function resolvePagesPageData(options) {
 		if (result?.props) pageProps = result.props;
 		if (result?.redirect) return {
 			kind: "response",
-			response: new Response(null, {
-				status: resolvePagesRedirectStatus(result.redirect),
-				headers: { Location: options.sanitizeDestination(result.redirect.destination) }
-			})
-		};
-		if (result?.notFound) return {
-			kind: "response",
-			response: options.isDataReq ? buildPagesDataNotFoundResponse() : buildPagesNotFoundResponse()
+			response: buildPagesRedirectResponse(result.redirect, options)
 		};
+		if (result?.notFound) return buildPagesNotFoundResult(options);
 		if (result?.props !== void 0) isSerializableProps(options.routePattern, "getStaticProps", pageProps);
 		if (typeof result?.revalidate === "number" && result.revalidate > 0) isrRevalidateSeconds = result.revalidate;
 	}
+	if (typeof options.pageModule.getServerSideProps !== "function" && typeof options.pageModule.getStaticProps !== "function" && hasPagesGetInitialProps(options.pageModule.default)) {
+		const { req, res, responsePromise } = options.createGsspReqRes();
+		const initialProps = await loadPagesGetInitialProps(options.pageModule.default, {
+			req,
+			res,
+			err: options.err,
+			pathname: options.routePattern,
+			query: options.query,
+			asPath: options.asPath ?? options.routeUrl,
+			locale: options.i18n.locale,
+			locales: options.i18n.locales,
+			defaultLocale: options.i18n.defaultLocale
+		});
+		if (isResponseSent(res)) return {
+			kind: "response",
+			response: await responsePromise
+		};
+		if (initialProps) pageProps = {
+			...pageProps,
+			...initialProps
+		};
+	}
 	return {
 		kind: "render",
 		gsspRes,
@@ -219,5 +263,3 @@ async function resolvePagesPageData(options) {
 }
 //#endregion
 export { renderPagesIsrHtml, resolvePagesPageData };
-
-//# sourceMappingURL=pages-page-data.js.map

package/dist/server/pages-page-handler.d.ts

@@ -0,0 +1,90 @@
+import { RenderPageEnhancers } from "./pages-document-initial-props.js";
+import { PagesPageModule } from "./pages-page-data.js";
+import { ComponentType, ReactNode } from "react";
+
+//#region src/server/pages-page-handler.d.ts
+type PageRoute = {
+  pattern: string;
+  patternParts: string[];
+  isDynamic: boolean;
+  params: string[];
+  module: PagesPageModule;
+  filePath: string;
+};
+type PageRouteMatch = {
+  route: PageRoute;
+  params: Record<string, string | string[]>;
+};
+type I18nConfig = {
+  locales: string[];
+  defaultLocale: string;
+  localeDetection?: boolean;
+  domains?: Array<{
+    domain: string;
+    defaultLocale: string;
+    locales?: string[];
+    http?: boolean;
+  }>;
+} | null;
+type VinextConfigSubset = {
+  basePath: string;
+  trailingSlash: boolean;
+  expireTime?: number;
+  clientTraceMetadata?: readonly string[];
+  disableOptimizedLoading: boolean;
+};
+/**
+ * Options accepted by `createPagesPageHandler`.
+ *
+ * All `next/*`-derived functions are passed as closures from the generated
+ * entry so this module avoids `next/*` imports and stays unit-testable.
+ */
+type CreatePagesPageHandlerOptions = {
+  /** Full page route table (built by the generated entry). */pageRoutes: PageRoute[]; /** The `_error` route when present; null otherwise. */
+  errorPageRoute: PageRoute | null; /** Route matcher — same function the entry uses for `matchRoute`. */
+  matchRoute: (url: string, routes: PageRoute[]) => PageRouteMatch | null; /** i18n config from next.config.js, or null when i18n is not configured. */
+  i18nConfig: I18nConfig; /** Subset of embedded vinextConfig used by the render pipeline. */
+  vinextConfig: VinextConfigSubset; /** Build ID embedded at build time (or null in dev). */
+  buildId: string | null; /** Whether the app has user-defined middleware. */
+  hasMiddleware: boolean; /** Absolute file path of `pages/_app` (or null). Used for manifest lookup. */
+  appAssetPath: string | null; /** `setSSRContext` from `next/router`. */
+  setSSRContext: ((ctx: Record<string, unknown> | null) => void) | null; /** `setI18nContext` from `vinext/i18n-context`. */
+  setI18nContext: ((ctx: Record<string, unknown>) => void) | null; /** `wrapWithRouterContext` from `next/router`. */
+  wrapWithRouterContext: ((element: ReactNode) => ReactNode) | null; /** `resetSSRHead` from `next/head`. */
+  resetSSRHead: (() => void) | undefined; /** `getSSRHeadHTML` from `next/head`. */
+  getSSRHeadHTML: (() => string) | undefined; /** `setDocumentInitialHead` from `next/head`. */
+  setDocumentInitialHead: ((head: ReactNode[]) => void) | undefined; /** `flushPreloads` from `next/dynamic`. */
+  flushPreloads: (() => Promise<void> | void) | undefined; /** `getSSRFontLinks` from `next/font/google`. */
+  getFontLinks: () => string[]; /** Combined styles from `next/font/google` + `next/font/local`. */
+  getFontStyles: () => string[]; /** Combined font preloads. */
+  getFontPreloads: () => Array<{
+    href: string;
+    type: string;
+  }>; /** `renderToReadableStream` from `react-dom/server.edge`. */
+  renderToReadableStream: (element: ReactNode) => Promise<ReadableStream<Uint8Array>>; /** Render a second ISR pass to a string (wraps renderToReadableStream). */
+  renderIsrPassToStringAsync: (element: ReactNode) => Promise<string>; /** `safeJsonStringify` from `vinext/html`. */
+  safeJsonStringify: (value: unknown) => string; /** `sanitizeDestination` from the config-matchers module. */
+  sanitizeDestination: (dest: string) => string; /** Build the React page element for a given set of page props. */
+  createPageElement: (PageComponent: ComponentType, AppComponent: ComponentType | null, pageProps: Record<string, unknown>) => ReactNode; /** Build the element with optional App/Component enhancers (for _document). */
+  enhancePageElement: (PageComponent: ComponentType, AppComponent: ComponentType | null, pageProps: Record<string, unknown>, opts: RenderPageEnhancers) => ReactNode; /** The `_app` page component (or null). */
+  AppComponent: ComponentType | null; /** The `_document` page component (or null). */
+  DocumentComponent: ComponentType | null;
+};
+type RenderPageOptions = {
+  isDataReq?: boolean;
+  statusCode?: number;
+  asPath?: string;
+  renderErrorPageOnMiss?: boolean;
+  __isInternalErrorRender?: boolean;
+  __forcedRoute?: PageRoute;
+  err?: unknown;
+};
+/**
+ * Create the Pages Router render function (`_renderPage`).
+ *
+ * The returned function is self-recursive for 404/500 fallback renders and
+ * accepts the same options shape the generated entry always passed inline.
+ */
+declare function createPagesPageHandler(opts: CreatePagesPageHandlerOptions): (request: Request, url: string, manifest: Record<string, string[]> | null | undefined, middlewareHeaders: Headers | null | undefined, options: RenderPageOptions | null | undefined) => Promise<Response>;
+//#endregion
+export { CreatePagesPageHandlerOptions, createPagesPageHandler };

package/dist/server/pages-page-handler.js

@@ -0,0 +1,335 @@
+import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { patternToNextFormat } from "../routing/route-validation.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { reportRequestError } from "./instrumentation.js";
+import { isrCacheKey, isrGet, isrSet, triggerBackgroundRegeneration } from "./isr-cache.js";
+import { ensureFetchPatch } from "../shims/fetch-cache.js";
+import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
+import { getScriptNonceFromHeaderSources } from "./csp.js";
+import { resolvePagesI18nRequest } from "./pages-i18n.js";
+import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
+import { resolvePagesPageMethodResponse } from "./pages-page-method.js";
+import { buildNextDataJsonResponse, buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
+import { createPagesReqRes } from "./pages-node-compat.js";
+import { collectAssetTags, resolveClientModuleUrl } from "./pages-asset-tags.js";
+import { renderPagesPageResponse } from "./pages-page-response.js";
+import { resolvePagesPageData } from "./pages-page-data.js";
+//#region src/server/pages-page-handler.ts
+function buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales) {
+	return {
+		locale,
+		locales: i18nConfig ? i18nConfig.locales : void 0,
+		defaultLocale: currentDefaultLocale,
+		domainLocales
+	};
+}
+/**
+* Create the Pages Router render function (`_renderPage`).
+*
+* The returned function is self-recursive for 404/500 fallback renders and
+* accepts the same options shape the generated entry always passed inline.
+*/
+function createPagesPageHandler(opts) {
+	const { pageRoutes, errorPageRoute, matchRoute, i18nConfig, vinextConfig, buildId, hasMiddleware, appAssetPath, setSSRContext, setI18nContext, wrapWithRouterContext, resetSSRHead, getSSRHeadHTML, setDocumentInitialHead, flushPreloads, getFontLinks, getFontStyles, getFontPreloads, renderToReadableStream, renderIsrPassToStringAsync, safeJsonStringify, sanitizeDestination, createPageElement, enhancePageElement, AppComponent, DocumentComponent } = opts;
+	function renderToStringAsync(element) {
+		return renderToReadableStream(element).then((stream) => new Response(stream).text());
+	}
+	function findNotFoundRoute() {
+		for (let i = 0; i < pageRoutes.length; i++) if (pageRoutes[i].pattern === "/404") return pageRoutes[i];
+		return errorPageRoute;
+	}
+	function isrCacheKeyForRequest(i18nCacheVariant) {
+		if (!i18nCacheVariant) return (router, pathname) => isrCacheKey(router, pathname, buildId ?? void 0);
+		return (router, pathname) => isrCacheKey(router, pathname + "::i18n=" + encodeURIComponent(i18nCacheVariant), buildId ?? void 0);
+	}
+	async function renderPage(request, url, manifest, middlewareHeaders, options) {
+		let isDataReq = !!(options && options.isDataReq);
+		if (!isDataReq) {
+			const dataNorm = normalizePagesDataRequest(request, buildId);
+			if (dataNorm.notFoundResponse) return dataNorm.notFoundResponse;
+			if (dataNorm.isDataReq) {
+				isDataReq = true;
+				if (url && url.startsWith("/_next/data/")) {
+					const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+					url = dataNorm.normalizedPathname + qs;
+				}
+			}
+		}
+		const statusCode = options && typeof options.statusCode === "number" ? options.statusCode : void 0;
+		const asPath = options && typeof options.asPath === "string" ? options.asPath : void 0;
+		const renderErrorPageOnMiss = !(options && options.renderErrorPageOnMiss === false);
+		const isInternalErrorRender = !!(options && options.__isInternalErrorRender);
+		const err = options && options.err;
+		const localeInfo = i18nConfig ? resolvePagesI18nRequest(url, i18nConfig, request.headers, new URL(request.url).hostname, vinextConfig.basePath, vinextConfig.trailingSlash) : {
+			locale: void 0,
+			url,
+			hadPrefix: false,
+			domainLocale: void 0,
+			redirectUrl: void 0
+		};
+		const locale = localeInfo.locale;
+		const routeUrl = localeInfo.url;
+		const currentDefaultLocale = i18nConfig ? localeInfo.domainLocale ? localeInfo.domainLocale.defaultLocale : i18nConfig.defaultLocale : void 0;
+		const domainLocales = i18nConfig ? i18nConfig.domains : void 0;
+		const pageIsrCacheKey = isrCacheKeyForRequest(i18nConfig ? localeInfo.domainLocale ? "domain:" + String(localeInfo.domainLocale.domain).toLowerCase() : "locale:" + String(locale) : null);
+		if (localeInfo.redirectUrl) return new Response(null, {
+			status: 307,
+			headers: { Location: localeInfo.redirectUrl }
+		});
+		let match = options && options.__forcedRoute ? {
+			route: options.__forcedRoute,
+			params: {}
+		} : matchRoute(routeUrl, pageRoutes);
+		let renderStatusCodeOverride = statusCode;
+		let renderAsPath = asPath;
+		if (!match) {
+			if (isDataReq) return buildNextDataNotFoundResponse();
+			if (!renderErrorPageOnMiss) return buildDefaultPagesNotFoundResponse();
+			const notFoundRoute = findNotFoundRoute();
+			if (notFoundRoute) {
+				match = {
+					route: notFoundRoute,
+					params: {}
+				};
+				renderStatusCodeOverride = 404;
+				renderAsPath = routeUrl;
+			} else return buildDefaultPagesNotFoundResponse();
+		}
+		const { route, params } = match;
+		return runWithRequestContext(createRequestContext({ executionContext: getRequestExecutionContext() }), async () => {
+			ensureFetchPatch();
+			try {
+				const routePattern = patternToNextFormat(route.pattern);
+				const renderStatusCode = renderStatusCodeOverride ?? (routePattern === "/404" ? 404 : void 0);
+				const query = mergeRouteParamsIntoQuery(parseQueryString(routeUrl), params);
+				function applySSRContext() {
+					if (typeof setSSRContext === "function") setSSRContext({
+						pathname: routePattern,
+						query,
+						asPath: renderAsPath ?? routeUrl,
+						locale,
+						locales: i18nConfig ? i18nConfig.locales : void 0,
+						defaultLocale: currentDefaultLocale,
+						domainLocales
+					});
+					if (i18nConfig && typeof setI18nContext === "function") setI18nContext({
+						locale,
+						locales: i18nConfig.locales,
+						defaultLocale: currentDefaultLocale,
+						domainLocales,
+						hostname: new URL(request.url).hostname
+					});
+				}
+				applySSRContext();
+				const pageModule = route.module;
+				const PageComponent = pageModule.default;
+				if (!PageComponent) return new Response("Page has no default export", { status: 500 });
+				if (!isDataReq && routePattern !== "/_error" && routePattern !== "/404" && routePattern !== "/500" && renderStatusCodeOverride === void 0) {
+					const methodResponse = resolvePagesPageMethodResponse({
+						hasGetServerSideProps: typeof pageModule.getServerSideProps === "function",
+						method: request.method
+					});
+					if (methodResponse) return methodResponse;
+				}
+				const pageModuleUrl = resolveClientModuleUrl(manifest, route.filePath);
+				const appModuleUrl = resolveClientModuleUrl(manifest, appAssetPath);
+				const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareHeaders);
+				let fontLinkHeader = "";
+				let allFontPreloads = [];
+				try {
+					allFontPreloads = getFontPreloads();
+					if (allFontPreloads.length > 0) fontLinkHeader = allFontPreloads.map((p) => "<" + p.href + ">; rel=preload; as=font; type=" + p.type + "; crossorigin").join(", ");
+				} catch {}
+				const pageDataResult = await resolvePagesPageData({
+					isDataReq,
+					err,
+					applyRequestContexts: applySSRContext,
+					buildId,
+					createGsspReqRes() {
+						return createPagesReqRes({
+							body: void 0,
+							query,
+							request,
+							url: routeUrl
+						});
+					},
+					createPageElement(currentPageProps) {
+						const el = createPageElement(PageComponent, AppComponent, currentPageProps);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					fontLinkHeader,
+					i18n: buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales),
+					isrCacheKey: pageIsrCacheKey,
+					isrGet,
+					isrSet,
+					expireSeconds: vinextConfig.expireTime,
+					isBuildTimePrerendering: typeof process !== "undefined" && process.env && process.env.VINEXT_PRERENDER === "1",
+					pageModule,
+					params,
+					query,
+					asPath: renderAsPath ?? routeUrl,
+					renderIsrPassToStringAsync,
+					route: { isDynamic: route.isDynamic },
+					routePattern,
+					routeUrl,
+					runInFreshUnifiedContext(callback) {
+						return runWithRequestContext(createRequestContext({ executionContext: getRequestExecutionContext() }), async () => {
+							ensureFetchPatch();
+							return callback();
+						});
+					},
+					safeJsonStringify,
+					sanitizeDestination,
+					scriptNonce,
+					statusCode: renderStatusCode,
+					triggerBackgroundRegeneration,
+					vinext: {
+						pageModuleUrl,
+						appModuleUrl,
+						hasMiddleware
+					}
+				});
+				if (pageDataResult.kind === "notFound") {
+					const notFoundRoute = findNotFoundRoute();
+					if (notFoundRoute && routePattern !== "/404" && routePattern !== "/_error") return renderPage(request, url, manifest, middlewareHeaders, {
+						statusCode: 404,
+						asPath: renderAsPath ?? routeUrl,
+						renderErrorPageOnMiss: false,
+						__forcedRoute: notFoundRoute
+					});
+					return buildDefaultPagesNotFoundResponse();
+				}
+				if (pageDataResult.kind === "response") return pageDataResult.response;
+				let pageProps = pageDataResult.pageProps;
+				if (routePattern === "/_error" && typeof renderStatusCode === "number") pageProps = {
+					...pageProps,
+					statusCode: renderStatusCode
+				};
+				const gsspRes = pageDataResult.gsspRes;
+				const isrRevalidateSeconds = pageDataResult.isrRevalidateSeconds;
+				const isFallbackRender = pageDataResult.isFallback === true;
+				if (isFallbackRender && typeof setSSRContext === "function") setSSRContext({
+					pathname: routePattern,
+					query,
+					asPath: renderAsPath ?? routeUrl,
+					locale,
+					locales: i18nConfig ? i18nConfig.locales : void 0,
+					defaultLocale: currentDefaultLocale,
+					domainLocales,
+					isFallback: true
+				});
+				if (isDataReq) {
+					const init = { headers: {} };
+					if (gsspRes && typeof gsspRes.getHeaders === "function") {
+						const gsspHeaders = gsspRes.getHeaders();
+						for (const k of Object.keys(gsspHeaders)) {
+							const v = gsspHeaders[k];
+							if (v === void 0 || v === null) continue;
+							init.headers[k] = Array.isArray(v) ? v.join(", ") : String(v);
+						}
+					}
+					if (gsspRes) {
+						let hasUserCacheControl = false;
+						for (const headerKey of Object.keys(init.headers)) if (headerKey.toLowerCase() === "cache-control") {
+							hasUserCacheControl = true;
+							break;
+						}
+						if (!hasUserCacheControl) init.headers["Cache-Control"] = "private, no-cache, no-store, max-age=0, must-revalidate";
+					}
+					return buildNextDataJsonResponse(pageProps, safeJsonStringify, init);
+				}
+				const pageModuleIds = [];
+				if (route.filePath) pageModuleIds.push(route.filePath);
+				if (appAssetPath) pageModuleIds.push(appAssetPath);
+				return await renderPagesPageResponse({
+					assetTags: collectAssetTags({
+						manifest,
+						moduleIds: pageModuleIds,
+						scriptNonce,
+						disableOptimizedLoading: vinextConfig.disableOptimizedLoading
+					}),
+					buildId,
+					clearSsrContext() {
+						if (typeof setSSRContext === "function") setSSRContext(null);
+					},
+					createPageElement(currentPageProps) {
+						const el = createPageElement(PageComponent, AppComponent, currentPageProps);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					enhancePageElement(renderPageOpts) {
+						const el = enhancePageElement(PageComponent, AppComponent, pageProps, renderPageOpts);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					DocumentComponent,
+					flushPreloads: typeof flushPreloads === "function" ? flushPreloads : void 0,
+					fontLinkHeader,
+					fontPreloads: allFontPreloads,
+					getFontLinks,
+					getFontStyles,
+					getSSRHeadHTML: typeof getSSRHeadHTML === "function" ? getSSRHeadHTML : void 0,
+					clientTraceMetadata: vinextConfig.clientTraceMetadata,
+					gsspRes,
+					isrCacheKey: pageIsrCacheKey,
+					expireSeconds: vinextConfig.expireTime,
+					isrRevalidateSeconds,
+					isrSet,
+					i18n: buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales),
+					isFallback: isFallbackRender,
+					pageProps,
+					params,
+					renderDocumentToString(element) {
+						return renderToStringAsync(element);
+					},
+					renderToReadableStream,
+					resetSSRHead: typeof resetSSRHead === "function" ? resetSSRHead : void 0,
+					setDocumentInitialHead: typeof setDocumentInitialHead === "function" ? setDocumentInitialHead : void 0,
+					routePattern,
+					routeUrl,
+					safeJsonStringify,
+					scriptNonce,
+					statusCode: renderStatusCode,
+					vinext: {
+						pageModuleUrl,
+						appModuleUrl,
+						hasMiddleware
+					}
+				});
+			} catch (e) {
+				console.error("[vinext] SSR error:", e);
+				reportRequestError(e instanceof Error ? e : new Error(String(e)), {
+					path: url,
+					method: request.method,
+					headers: Object.fromEntries(request.headers.entries())
+				}, {
+					routerKind: "Pages Router",
+					routePath: route.pattern,
+					routeType: "render"
+				}).catch(() => {});
+				if (!isInternalErrorRender && !isDataReq) {
+					let errorRoute = null;
+					for (let i = 0; i < pageRoutes.length; i++) if (pageRoutes[i].pattern === "/500") {
+						errorRoute = pageRoutes[i];
+						break;
+					}
+					if (!errorRoute && errorPageRoute) errorRoute = errorPageRoute;
+					if (errorRoute) try {
+						return await renderPage(request, url, manifest, middlewareHeaders, {
+							statusCode: 500,
+							asPath: url,
+							renderErrorPageOnMiss: false,
+							__isInternalErrorRender: true,
+							__forcedRoute: errorRoute,
+							err: e instanceof Error ? e : new Error(String(e))
+						});
+					} catch (errorPageErr) {
+						console.error("[vinext] Error page render failed:", errorPageErr);
+					}
+				}
+				return new Response("Internal Server Error", { status: 500 });
+			}
+		});
+	}
+	return renderPage;
+}
+//#endregion
+export { createPagesPageHandler };

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

@@ -44,5 +44,4 @@ type PagesPageMethodOptions = {
  */
 declare function resolvePagesPageMethodResponse(options: PagesPageMethodOptions): Response | null;
 //#endregion
-export { resolvePagesPageMethodResponse };
-//# sourceMappingURL=pages-page-method.d.ts.map
+export { resolvePagesPageMethodResponse };

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

@@ -15,5 +15,3 @@ function resolvePagesPageMethodResponse(options) {
 }
 //#endregion
 export { resolvePagesPageMethodResponse };
-
-//# sourceMappingURL=pages-page-method.js.map

package/dist/server/pages-page-response.d.ts

@@ -1,5 +1,6 @@
 import { VinextNextData } from "../client/vinext-next-data.js";
 import { CachedPagesValue } from "../shims/cache.js";
+import { RenderPageEnhancers } from "./pages-document-initial-props.js";
 import { ComponentType, ReactNode } from "react";
 
 //#region src/server/pages-page-response.d.ts
@@ -22,6 +23,18 @@ type RenderPagesPageResponseOptions = {
   buildId: string | null;
   clearSsrContext: () => void;
   createPageElement: (pageProps: Record<string, unknown>) => ReactNode;
+  /**
+   * Build the page React tree with optional App/Component enhancers applied,
+   * supporting the Pages Router `_document.getInitialProps` contract:
+   *
+   *   ctx.renderPage({ enhanceApp, enhanceComponent })
+   *
+   * Used by CSS-in-JS libraries (styled-components, emotion) to wrap the
+   * App/Component tree so styles can be collected during SSR. When omitted,
+   * `renderPage` falls back to rendering the plain `createPageElement` tree
+   * (enhancers are ignored).
+   */
+  enhancePageElement?: ((opts: RenderPageEnhancers) => ReactNode) | undefined;
   DocumentComponent: ComponentType | null;
   flushPreloads?: (() => Promise<void> | void) | undefined;
   fontLinkHeader: string;
@@ -35,6 +48,7 @@ type RenderPagesPageResponseOptions = {
    * head. Undefined or empty disables emission.
    */
   clientTraceMetadata?: readonly string[] | undefined;
+  setDocumentInitialHead?: ((head: ReactNode[]) => void) | undefined;
   gsspRes: PagesGsspResponse | null;
   isrCacheKey: (router: string, pathname: string) => string;
   expireSeconds?: number;
@@ -65,5 +79,4 @@ declare function buildPagesNextDataScript(options: Pick<RenderPagesPageResponseO
 }): string;
 declare function renderPagesPageResponse(options: RenderPagesPageResponseOptions): Promise<Response>;
 //#endregion
-export { PagesGsspResponse, PagesI18nRenderContext, buildPagesNextDataScript, renderPagesPageResponse };
-//# sourceMappingURL=pages-page-response.d.ts.map
+export { PagesGsspResponse, PagesI18nRenderContext, buildPagesNextDataScript, renderPagesPageResponse };