@qzsy/vinext 0.1.7

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

@@ -0,0 +1,403 @@
+import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { patternToNextFormat } from "../routing/route-validation.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
+import { reportRequestError } from "./instrumentation.js";
+import { NEVER_CACHE_CONTROL } from "./cache-control.js";
+import "./isr-decision.js";
+import { PRERENDER_REVALIDATE_HEADER, isOnDemandRevalidateRequest, isrCacheKey, isrGet, isrSet, triggerBackgroundRegeneration } from "./isr-cache.js";
+import { ensureFetchPatch } from "../shims/fetch-cache.js";
+import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.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 { buildPagesReadinessNextData } from "./pages-readiness.js";
+import { resolvePagesPageMethodResponse } from "./pages-page-method.js";
+import { buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, normalizePagesDataRequest, parseNextDataPathname } 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, hasRewrites, setSSRContext, getPagesNavigationIsReadyFromSerializedState, 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);
+		const requestUrl = new URL(request.url);
+		const rawOriginalUrl = options && typeof options.originalUrl === "string" ? options.originalUrl : requestUrl.pathname + requestUrl.search;
+		const originalRequestUrl = new URL(rawOriginalUrl, requestUrl);
+		const originalRequestPathAndSearch = originalRequestUrl.pathname + originalRequestUrl.search;
+		let dataRequestPathname = null;
+		let dataRequestSearch = "";
+		const initialDataNorm = normalizePagesDataRequest(request, buildId);
+		if (!isDataReq) {
+			if (initialDataNorm.notFoundResponse) return initialDataNorm.notFoundResponse;
+			if (initialDataNorm.isDataReq) {
+				isDataReq = true;
+				dataRequestPathname = initialDataNorm.normalizedPathname;
+				dataRequestSearch = initialDataNorm.search;
+				if (url && url.startsWith("/_next/data/")) {
+					const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+					url = initialDataNorm.normalizedPathname + qs;
+				}
+			}
+		} else if (initialDataNorm.isDataReq) {
+			dataRequestPathname = initialDataNorm.normalizedPathname;
+			dataRequestSearch = initialDataNorm.search;
+		}
+		if (isDataReq && dataRequestPathname === null && buildId) {
+			const originalDataMatch = parseNextDataPathname(originalRequestUrl.pathname, buildId);
+			if (originalDataMatch) {
+				dataRequestPathname = originalDataMatch.pagePathname;
+				dataRequestSearch = originalRequestUrl.search;
+			}
+		}
+		const statusCode = options && typeof options.statusCode === "number" ? options.statusCode : void 0;
+		const defaultAsPath = isDataReq && dataRequestPathname ? dataRequestPathname + dataRequestSearch : originalRequestPathAndSearch;
+		const asPath = options && typeof options.asPath === "string" ? options.asPath : defaultAsPath;
+		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);
+				const pageModule = route.module;
+				const pagesNextData = buildPagesReadinessNextData({
+					pageModule,
+					appComponent: AppComponent,
+					hasRewrites
+				});
+				const navigationIsReady = typeof getPagesNavigationIsReadyFromSerializedState === "function" ? getPagesNavigationIsReadyFromSerializedState(routePattern, new URL(renderAsPath ?? routeUrl, "http://_").search, pagesNextData) : true;
+				function applySSRContext(extra) {
+					if (typeof setSSRContext === "function") setSSRContext({
+						pathname: routePattern,
+						query,
+						asPath: renderAsPath ?? routeUrl,
+						navigationIsReady,
+						locale,
+						locales: i18nConfig ? i18nConfig.locales : void 0,
+						defaultLocale: currentDefaultLocale,
+						domainLocales,
+						...extra
+					});
+					if (i18nConfig && typeof setI18nContext === "function") setI18nContext({
+						locale,
+						locales: i18nConfig.locales,
+						defaultLocale: currentDefaultLocale,
+						domainLocales,
+						hostname: new URL(request.url).hostname
+					});
+				}
+				applySSRContext({ nextData: pagesNextData });
+				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, vinextConfig.basePath, vinextConfig.assetPrefix, process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID);
+				const appModuleUrl = resolveClientModuleUrl(manifest, appAssetPath, vinextConfig.basePath, vinextConfig.assetPrefix, process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID);
+				const serializedPagesNextData = {
+					...pagesNextData,
+					__vinext: {
+						...pagesNextData.__vinext,
+						pageModuleUrl,
+						appModuleUrl,
+						hasMiddleware
+					}
+				};
+				const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareHeaders);
+				let fontLinkHeader = "";
+				let allFontPreloads = [];
+				try {
+					allFontPreloads = getFontPreloads();
+					if (allFontPreloads.length > 0) fontLinkHeader = allFontPreloads.map((p) => "<" + appendAssetDeploymentIdQuery(p.href) + ">; rel=preload; as=font; type=" + p.type + "; crossorigin").join(", ");
+				} catch {}
+				const pagesResolvedUrl = (new URL(routeUrl, originalRequestUrl).pathname || "/") + originalRequestUrl.search;
+				const pageDataResult = await resolvePagesPageData({
+					isDataReq,
+					err: err instanceof Error ? err : void 0,
+					applyRequestContexts: applySSRContext,
+					buildId,
+					deploymentId: process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID,
+					htmlLimitedBots: vinextConfig.htmlLimitedBots,
+					createGsspReqRes() {
+						return createPagesReqRes({
+							body: void 0,
+							query,
+							request,
+							url: originalRequestPathAndSearch
+						});
+					},
+					createAppTree(appTreeProps) {
+						const el = createPageElement(PageComponent, AppComponent, appTreeProps);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					createPageElement(currentProps) {
+						const el = createPageElement(PageComponent, AppComponent, currentProps);
+						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",
+					isOnDemandRevalidate: isOnDemandRevalidateRequest(request.headers.get(PRERENDER_REVALIDATE_HEADER)),
+					pageModule,
+					AppComponent,
+					params,
+					query,
+					asPath: renderAsPath ?? routeUrl,
+					resolvedUrl: pagesResolvedUrl,
+					renderIsrPassToStringAsync,
+					route: { isDynamic: route.isDynamic },
+					routePattern,
+					routeUrl,
+					runInFreshUnifiedContext(callback) {
+						return runWithRequestContext(createRequestContext({ executionContext: null }), async () => {
+							ensureFetchPatch();
+							return callback();
+						});
+					},
+					safeJsonStringify,
+					sanitizeDestination,
+					scriptNonce,
+					statusCode: renderStatusCode,
+					triggerBackgroundRegeneration,
+					vinext: serializedPagesNextData.__vinext,
+					nextData: serializedPagesNextData,
+					userAgent: request.headers.get("user-agent") ?? void 0,
+					ifNoneMatch: request.headers.get("if-none-match") ?? void 0,
+					requestCacheControl: request.headers.get("cache-control") ?? void 0
+				});
+				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;
+				let renderProps = pageDataResult.props;
+				if (routePattern === "/_error" && typeof renderStatusCode === "number") {
+					pageProps = {
+						...pageProps,
+						statusCode: renderStatusCode
+					};
+					renderProps = {
+						...renderProps,
+						pageProps
+					};
+				}
+				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,
+					navigationIsReady: false,
+					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"] = NEVER_CACHE_CONTROL;
+					}
+					if (routePattern !== "/_error" && routePattern !== "/500") {
+						const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
+						if (deploymentId) init.headers[NEXTJS_DEPLOYMENT_ID_HEADER] = deploymentId;
+					}
+					return buildNextDataPropsJsonResponse(renderProps, 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,
+						basePath: vinextConfig.basePath,
+						assetPrefix: vinextConfig.assetPrefix,
+						deploymentId: process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID
+					}),
+					buildId,
+					clearSsrContext() {
+						if (typeof setSSRContext === "function") setSSRContext(null);
+					},
+					createPageElement(currentProps) {
+						const el = createPageElement(PageComponent, AppComponent, currentProps);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					enhancePageElement(renderPageOpts) {
+						const el = enhancePageElement(PageComponent, AppComponent, renderProps, renderPageOpts);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					DocumentComponent,
+					err: err instanceof Error ? err : void 0,
+					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,
+					props: renderProps,
+					params,
+					query,
+					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,
+					nextData: serializedPagesNextData,
+					userAgent: request.headers.get("user-agent") ?? void 0,
+					ifNoneMatch: request.headers.get("if-none-match") ?? void 0,
+					requestCacheControl: request.headers.get("cache-control") ?? void 0
+				});
+			} 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

@@ -0,0 +1,47 @@
+//#region src/server/pages-page-method.d.ts
+/**
+ * Pages Router method-allow policy.
+ *
+ * Mirrors Next.js's behavior in
+ * `.nextjs-ref/packages/next/src/server/base-server.ts` around L2277:
+ *
+ *   if (
+ *     !isPossibleServerAction &&
+ *     !minimalPostponed &&
+ *     !is404Page &&
+ *     !is500Page &&
+ *     pathname !== '/_error' &&
+ *     req.method !== 'HEAD' &&
+ *     req.method !== 'GET' &&
+ *     (typeof components.Component === 'string' || isSSG)
+ *   ) {
+ *     res.statusCode = 405
+ *     res.setHeader('Allow', ['GET', 'HEAD'])
+ *     res.body('Method Not Allowed').send()
+ *     return null
+ *   }
+ *
+ * In vinext, a Pages Router route is "static" (no SSR per-request work) when
+ * it does not export `getServerSideProps`. Such routes — including plain
+ * components and `getStaticProps` (GSP) pages — must reject non-GET/HEAD
+ * requests with 405 + `Allow: GET, HEAD`.
+ *
+ * Server Actions (Pages Router supports `"use server"` for forms in newer
+ * Next.js versions) are out of scope here: vinext's Pages Router does not
+ * implement them, so there's no carve-out to add. If/when it does, this
+ * helper should grow an `isPossibleServerAction` opt-out parameter mirroring
+ * the App Router's `resolveAppPageMethodResponse`.
+ *
+ * Refs #1463.
+ */
+type PagesPageMethodOptions = {
+  hasGetServerSideProps: boolean;
+  method: string;
+};
+/**
+ * Returns a 405 `Response` when the request method is not allowed for a
+ * static (no `getServerSideProps`) Pages Router page, otherwise `null`.
+ */
+declare function resolvePagesPageMethodResponse(options: PagesPageMethodOptions): Response | null;
+//#endregion
+export { resolvePagesPageMethodResponse };

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

@@ -0,0 +1,17 @@
+import { methodNotAllowedResponse } from "./http-error-responses.js";
+//#region src/server/pages-page-method.ts
+function isNonGetOrHead(method) {
+	const normalizedMethod = method.toUpperCase();
+	return normalizedMethod !== "GET" && normalizedMethod !== "HEAD";
+}
+/**
+* Returns a 405 `Response` when the request method is not allowed for a
+* static (no `getServerSideProps`) Pages Router page, otherwise `null`.
+*/
+function resolvePagesPageMethodResponse(options) {
+	if (!isNonGetOrHead(options.method)) return null;
+	if (options.hasGetServerSideProps) return null;
+	return methodNotAllowedResponse("GET, HEAD");
+}
+//#endregion
+export { resolvePagesPageMethodResponse };

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

@@ -0,0 +1,138 @@
+import { VinextNextData } from "../client/vinext-next-data.js";
+import { CachedPagesValue } from "../shims/cache-handler.js";
+import { RenderPageEnhancers } from "./pages-document-initial-props.js";
+import { ComponentType, ReactNode } from "react";
+
+//#region src/server/pages-page-response.d.ts
+/**
+ * Returns true when the User-Agent belongs to a bot or crawler that cannot
+ * reliably consume a streamed HTML response.
+ */
+declare function isPagesStreamingBot(userAgent: string): boolean;
+declare function generatePagesETag(payload: string): string;
+/**
+ * Mirrors Next.js `sendEtagResponse` semantics (weak/strong comparison).
+ *
+ * A weak ETag `W/"..."` matches both `W/"..."` and `"..."` in `If-None-Match`.
+ * A strong ETag `"..."` only matches the same strong token.
+ * `*` always matches.
+ */
+declare function etagMatches(etag: string, ifNoneMatch: string): boolean;
+/**
+ * Returns true when a request `Cache-Control` header asks to bypass the 304
+ * short-circuit. Mirrors the `fresh` package's check used by Next.js's
+ * `sendEtagResponse` (`/(?:^|,)\s*?no-cache\s*?(?:,|$)/`). Shared by the
+ * fresh-MISS bot path here and the ISR HIT/STALE paths in
+ * `pages-page-data.ts` so the two cannot drift.
+ */
+declare function requestsNoCache(cacheControl: string | undefined): boolean;
+type PagesFontPreload = {
+  href: string;
+  type: string;
+};
+/**
+ * The `__NEXT_DATA__` fields beyond the always-present core that the Pages
+ * renderer serializes: the `__vinext` block plus the readiness flags
+ * (gssp/gsp/gip/appGip/autoExport/isExperimentalCompile) the client uses to
+ * recompute the initial `router.isReady`. Shared by every render path
+ * (initial, ISR regeneration) so they emit identical readiness state.
+ */
+type PagesNextDataExtras = Pick<VinextNextData, "__vinext" | "appGip" | "autoExport" | "gip" | "gsp" | "gssp" | "isExperimentalCompile">;
+type PagesI18nRenderContext = {
+  locale?: string;
+  locales?: string[];
+  defaultLocale?: string;
+  domainLocales?: unknown;
+};
+type PagesGsspResponse = {
+  statusCode: number;
+  getHeaders(): Record<string, string | number | boolean | string[]>;
+};
+type RenderPagesPageResponseOptions = {
+  assetTags: string;
+  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;
+  err?: Error;
+  flushPreloads?: (() => Promise<void> | void) | undefined;
+  fontLinkHeader: string;
+  fontPreloads: PagesFontPreload[];
+  getFontLinks: () => string[];
+  getFontStyles: () => string[];
+  getSSRHeadHTML?: (() => string) | undefined;
+  /**
+   * Allow-list of OpenTelemetry propagation keys (from
+   * `experimental.clientTraceMetadata`) to emit as `<meta>` tags in the SSR
+   * 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;
+  isrRevalidateSeconds: number | null;
+  isrSet: (key: string, data: CachedPagesValue, revalidateSeconds: number, tags?: string[], expireSeconds?: number) => Promise<void>;
+  i18n: PagesI18nRenderContext;
+  /**
+   * True when rendering a `getStaticPaths` fallback shell for a path that
+   * isn't pre-rendered (`fallback: true` + unlisted path). Forwarded to
+   * `buildPagesNextDataScript` so the client serialises `isFallback: true`
+   * into `__NEXT_DATA__`, then later hydrates by fetching the data URL.
+   */
+  isFallback?: boolean;
+  pageProps: Record<string, unknown>;
+  props?: Record<string, unknown>;
+  params: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  renderDocumentToString: (element: ReactNode) => Promise<string>;
+  renderToReadableStream: (element: ReactNode) => Promise<ReadableStream<Uint8Array>>;
+  resetSSRHead?: (() => void) | undefined;
+  routePattern: string;
+  routeUrl: string;
+  safeJsonStringify: (value: unknown) => string;
+  scriptNonce?: string;
+  statusCode?: number;
+  vinext?: VinextNextData["__vinext"];
+  nextData?: PagesNextDataExtras;
+  /**
+   * The request's User-Agent string (from `request.headers.get('user-agent')`).
+   * When this matches a known crawler / bot pattern, the response is fully
+   * buffered before sending so bots receive a single complete HTML chunk with
+   * an ETag header. Omitting this field disables bot-detection (streaming as
+   * normal), which is the correct behaviour for non-HTML requests and tests.
+   */
+  userAgent?: string;
+  /**
+   * The incoming request's `If-None-Match` header value. When set and the
+   * computed ETag matches (weak-ETag semantics, mirroring Next.js's
+   * `sendEtagResponse`), a `304 Not Modified` is returned with an empty body.
+   * Only evaluated on bot/buffered responses that carry an ETag.
+   */
+  ifNoneMatch?: string;
+  /**
+   * The incoming request's `Cache-Control` header value. When the value
+   * contains `no-cache`, the 304 short-circuit is skipped and a full 200
+   * response is always returned — mirroring the `fresh` package used by
+   * Next.js's `sendEtagResponse`.
+   */
+  requestCacheControl?: string;
+};
+declare function buildPagesNextDataScript(options: Pick<RenderPagesPageResponseOptions, "buildId" | "i18n" | "isFallback" | "pageProps" | "props" | "params" | "routePattern" | "safeJsonStringify" | "scriptNonce" | "nextData"> & {
+  vinext?: VinextNextData["__vinext"];
+}): string;
+declare function renderPagesPageResponse(options: RenderPagesPageResponseOptions): Promise<Response>;
+//#endregion
+export { PagesGsspResponse, PagesI18nRenderContext, PagesNextDataExtras, buildPagesNextDataScript, etagMatches, generatePagesETag, isPagesStreamingBot, renderPagesPageResponse, requestsNoCache };