vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/pages-request-stage-entry.js

@@ -0,0 +1,314 @@
+import { VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import { requestContextFromRequest } from "../config/request-context.js";
+import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
+import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
+import { hasBasePath, stripBasePath } from "../utils/base-path.js";
+import { runWithExecutionContext } from "../shims/request-context.js";
+import { VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "./headers.js";
+import { notFoundStaticAssetResponse } from "./http-error-responses.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
+import { attachRequestCfMetadata, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders } from "./request-pipeline.js";
+import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { CACHEABILITY_REQUEST_STATE } from "../shims/cacheability-classification.js";
+import { applyCdnResponseIdentityHeaders, captureCdnResponsePolicyOverrides, reconcileCdnResponseHeadersAfterOuterPolicy, validateCdnRequest } from "./cache-control.js";
+import { registerLazyDataCacheHandler } from "../shims/cache-handler.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
+import { traceFrameworkRequest } from "./request-tracing.js";
+import { resolveResponseStageCachePolicy } from "./config-headers.js";
+import { finalizeMissingStaticAssetResponse } from "./worker-utils.js";
+import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
+import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
+import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse, isWorkerPrerenderDiscoveryPath } from "./worker-prerender-discovery.js";
+import { getPagesResponseStageCacheDisposition } from "./pages-response-stage.js";
+import "./worker-stages.js";
+import { consumePagesResponseStagePolicyOwner, prependResponseStageAdditiveHeaders, withResponseStageVary, withoutResponseStageVary } from "./response-stage-policy.js";
+import * as configuredCdnCacheAdapters from "virtual:vinext-cdn-cache-adapter";
+import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
+import * as pagesEntry from "virtual:vinext-pages-request-entry";
+//#region src/server/pages-request-stage-entry.ts
+/**
+* Request-stage entry point for vinext Pages Router.
+*
+* The public pages-router-entry delegates here. Multi-stage hosts import the
+* named request handler directly and provide their response-stage dispatcher.
+*/
+function haveSameHeaders(first, second) {
+	const firstEntries = [...first];
+	const secondEntries = [...second];
+	return firstEntries.length === secondEntries.length && firstEntries.every(([name, value], index) => name === secondEntries[index]?.[0] && value === secondEntries[index]?.[1]);
+}
+function captureOuterResponsePolicyHeaders(stagedHeaders, transportedPolicyHeaders) {
+	return captureCdnResponsePolicyOverrides(stagedHeaders, new Headers(transportedPolicyHeaders ?? []));
+}
+const { authorizeOnDemandRevalidate, hasMiddleware, hasRequestAwareDocument, matchApiRoute, matchPageRoute, normalizeDataRequest, publicFiles, runMiddleware, vinextConfig } = pagesEntry;
+const pagesRequestStageBuildId = pagesEntry.buildId ?? null;
+const pagesRequestStagePrerenderSecret = pagesEntry.prerenderSecret ?? null;
+const basePath = vinextConfig?.basePath ?? "";
+const assetPathPrefix = assetPrefixPathname(vinextConfig?.assetPrefix ?? "");
+const trailingSlash = vinextConfig?.trailingSlash ?? false;
+const i18nConfig = vinextConfig?.i18n ?? null;
+const configRedirects = vinextConfig?.redirects ?? [];
+const configRewrites = vinextConfig?.rewrites ?? {
+	beforeFiles: [],
+	afterFiles: [],
+	fallback: []
+};
+const configHeaders = vinextConfig?.headers ?? [];
+const imageConfig = vinextConfig?.images ? {
+	qualities: vinextConfig.images.qualities,
+	dangerouslyAllowSVG: vinextConfig.images.dangerouslyAllowSVG,
+	dangerouslyAllowLocalIP: vinextConfig.images.dangerouslyAllowLocalIP,
+	contentDispositionType: vinextConfig.images.contentDispositionType,
+	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
+} : void 0;
+/** Run the request-time stage with a host-owned response dispatcher. */
+function handleRequestStage(request, env, ctx, dispatchResponseStage) {
+	const originalRequest = request;
+	return handleRequest(request, env, ctx, (stageRequest, props, options) => dispatchResponseStage(stageRequest, props, options), false, "node", ctx?.assets).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest));
+}
+/** Preserve the direct single-entry Worker path without retaining it in request-only builds. */
+function handleRequestStageLocally(request, env, ctx, dispatchResponseStage) {
+	const originalRequest = request;
+	return handleRequest(request, env, ctx, (stageRequest, props, _options, stageEnv, stageCtx) => dispatchResponseStage(stageRequest, stageEnv, stageCtx, props), true, "worker", env?.ASSETS).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest));
+}
+function handleRequest(request, env, platformCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets) {
+	const url = new URL(request.url);
+	const trace = async () => {
+		await pagesEntry.__ensureInstrumentation?.();
+		return traceFrameworkRequest({
+			callback: () => handleRequestImpl(request, env, platformCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets),
+			getStatus: (response) => response?.status,
+			headers: request.headers,
+			method: request.method,
+			target: url.pathname + url.search
+		});
+	};
+	return platformCtx && typeof platformCtx.waitUntil === "function" && (!forceCacheBypass || !Reflect.has(platformCtx, CACHEABILITY_REQUEST_STATE)) ? runWithExecutionContext(platformCtx, trace) : trace();
+}
+async function handleRequestImpl(request, env, platformCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets) {
+	let sharedResponseHeaders = null;
+	let sharedOuterPolicyHeaders = null;
+	let ctx = createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets), defaultHostRuntime);
+	configuredCdnCacheAdapters.registerConfiguredCacheAdapters(env);
+	if (configuredCdnCacheAdapters.hasConfiguredDataCache) registerLazyDataCacheHandler(async () => {
+		(await import("virtual:vinext-cache-adapters")).registerConfiguredCacheAdapters(env);
+	});
+	registerConfiguredImageOptimizer(env);
+	try {
+		ctx = createWorkerPrerenderDiscoveryContext(ctx, request, pagesEntry.prerenderSecret);
+		const readinessResponse = createWorkerPrerenderReadinessResponse(ctx, request);
+		let didValidateCdnRequest = false;
+		if (readinessResponse) {
+			const validationResponse = await validateCdnRequest(request);
+			if (validationResponse) return validationResponse;
+			didValidateCdnRequest = true;
+			if (readinessResponse.status !== 204) return readinessResponse;
+		}
+		let probeMode = null;
+		let probeRoute = null;
+		if (request.headers.has("X-Vinext-Cacheability-Probe")) {
+			const { readWorkerCacheabilityProbeMode, readWorkerCacheabilityProbeRoute } = await import("./cacheability-request.js");
+			probeMode = readWorkerCacheabilityProbeMode(request, pagesEntry.prerenderSecret);
+			if (probeMode) {
+				probeRoute = readWorkerCacheabilityProbeRoute(request);
+				const probeUrl = new URL(request.url);
+				probeUrl.searchParams.delete(VINEXT_CACHEABILITY_PROBE_QUERY_PARAM);
+				request = new Request(probeUrl, request);
+			}
+		}
+		let responseStageDispatched = false;
+		const trackedDispatchResponseStage = (stageRequest, props, options, stageEnv, stageCtx) => {
+			responseStageDispatched = true;
+			return dispatchResponseStage(stageRequest, props, options, stageEnv, stageCtx);
+		};
+		if (!didValidateCdnRequest) {
+			const cdnValidationResponse = await validateCdnRequest(request);
+			if (cdnValidationResponse) return cdnValidationResponse;
+		}
+		const filteredHeaders = ctx.isInternalPagesRevalidation ? new Headers(request.headers) : filterInternalHeaders(request.headers);
+		filteredHeaders.delete(VINEXT_PRERENDER_SECRET_HEADER);
+		filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
+		if (readinessResponse?.status === 204) {
+			const expectedWorkerVersion = request.headers.get(VINEXT_EXPECTED_WORKER_VERSION_HEADER);
+			if (expectedWorkerVersion) filteredHeaders.set(VINEXT_EXPECTED_WORKER_VERSION_HEADER, expectedWorkerVersion);
+		}
+		request = cloneRequestWithHeaders(request, filteredHeaders);
+		const url = new URL(request.url);
+		let pathname = url.pathname;
+		if (ctx.isPrerenderPathDiscovery && isWorkerPrerenderDiscoveryPath(pathname)) return trackedDispatchResponseStage(request, {
+			buildId: pagesEntry.buildId,
+			cacheability: {
+				policyHeaders: null,
+				probeMode: null,
+				resolvedRoutePathname: pathname
+			},
+			kind: "pages-prerender-discovery",
+			protocolVersion: 4,
+			requestHost: url.host,
+			stagedHeaders: null
+		}, { cache: "bypass" }, env, ctx);
+		if (isOpenRedirectShaped(pathname)) return new Response("This page could not be found", { status: 404 });
+		try {
+			normalizePathnameForRouteMatchStrict(pathname);
+		} catch {
+			return new Response("Bad Request", { status: 400 });
+		}
+		const missingBuildAsset = isNextStaticPath(pathname, basePath, assetPathPrefix);
+		const hadBasePath = !basePath || hasBasePath(pathname, basePath);
+		{
+			const stripped = stripBasePath(pathname, basePath);
+			if (stripped !== pathname) {
+				const strippedUrl = new URL(request.url);
+				strippedUrl.pathname = stripped;
+				request = cloneRequestWithUrl(request, strippedUrl.toString());
+				pathname = stripped;
+			}
+		}
+		const middlewareRequest = request;
+		const dataNorm = normalizeDataRequest(request);
+		if (dataNorm.notFoundResponse && !vinextConfig?.skipProxyUrlNormalize) return dataNorm.notFoundResponse;
+		const isDataReq = dataNorm.isDataReq;
+		if (isDataReq && dataNorm.normalizedPathname) {
+			request = dataNorm.request;
+			pathname = dataNorm.normalizedPathname;
+		}
+		const responseStagePolicyPathname = i18nConfig ? normalizeDefaultLocalePathname(pathname, i18nConfig, { hostname: url.hostname }) : pathname;
+		const responseStagePolicyHeaders = resolveResponseStageCachePolicy({
+			basePathState: {
+				basePath,
+				hadBasePath
+			},
+			configHeaders,
+			pathname: responseStagePolicyPathname,
+			requestContext: requestContextFromRequest(request)
+		});
+		let speculativeRenderRequest = null;
+		const deps = {
+			basePath,
+			trailingSlash,
+			i18nConfig,
+			configRedirects,
+			configRewrites,
+			configHeaders,
+			hadBasePath,
+			isDataReq,
+			isDataRequest: isDataReq,
+			hasMiddleware,
+			ctx,
+			recordCacheability: forceCacheBypass,
+			middlewareRequest: isDataReq && vinextConfig?.skipProxyUrlNormalize ? middlewareRequest : void 0,
+			dataNotFoundResponse: vinextConfig?.skipProxyUrlNormalize ? dataNorm.notFoundResponse : null,
+			authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
+			matchApiRoute: typeof matchApiRoute === "function" ? matchApiRoute : null,
+			matchPageRoute: typeof matchPageRoute === "function" ? matchPageRoute : null,
+			runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) : null,
+			renderPage: (req, resolvedUrl, options, stagedHeaders) => {
+				if (options?.renderErrorPageOnMiss === false && req.body !== null && !req.bodyUsed) speculativeRenderRequest = req;
+				const stageRequest = speculativeRenderRequest === req && req.body !== null && !req.bodyUsed ? attachRequestCfMetadata(req.clone(), req) : req;
+				const matchedPage = typeof matchPageRoute === "function" ? matchPageRoute(resolvedUrl, req) : null;
+				const cache = forceCacheBypass || probeMode ? "bypass" : getPagesResponseStageCacheDisposition({
+					authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
+					hasRequestAwareDocument: hasRequestAwareDocument === true,
+					request: req,
+					requestHeadersChanged: !haveSameHeaders(filteredHeaders, req.headers),
+					routeDataKind: matchedPage?.route.dataKind,
+					stagedHeaders
+				});
+				const isSharedStaticPage = cache === "shared" && matchedPage?.route.dataKind === "static";
+				const transportedPolicyHeaders = isSharedStaticPage ? withoutResponseStageVary(responseStagePolicyHeaders) : withResponseStageVary(responseStagePolicyHeaders, stagedHeaders?.get("Vary"));
+				const responseStageProps = () => ({
+					buildId: pagesEntry.buildId,
+					cacheability: {
+						policyHeaders: transportedPolicyHeaders,
+						probeMode,
+						...isDataReq ? { representation: "pages-data" } : {},
+						resolvedRoutePathname: new URL(resolvedUrl, req.url).pathname
+					},
+					kind: "pages-page",
+					protocolVersion: 4,
+					requestHost: new URL(req.url).host,
+					renderOptions: options ?? null,
+					resolvedUrl,
+					stagedHeaders: isSharedStaticPage ? null : [...stagedHeaders ?? new Headers()]
+				});
+				const isHeadRequest = req.method.toUpperCase() === "HEAD";
+				const responsePromise = trackedDispatchResponseStage(stageRequest, responseStageProps(), { cache }, env, ctx).then((response) => {
+					const consumed = consumePagesResponseStagePolicyOwner(response);
+					if (cache === "shared") {
+						if (isSharedStaticPage && stagedHeaders) prependResponseStageAdditiveHeaders(consumed.response.headers, stagedHeaders);
+						sharedResponseHeaders = new Headers(consumed.response.headers);
+						sharedOuterPolicyHeaders = !(consumed.owner === "request-time" || consumed.owner === null && matchedPage?.route.dataKind === "server") ? captureOuterResponsePolicyHeaders(stagedHeaders ?? new Headers(), transportedPolicyHeaders) : null;
+					}
+					return consumed.response;
+				});
+				if (!isHeadRequest) return responsePromise;
+				return responsePromise.then(async (response) => {
+					await response.body?.cancel();
+					return new Response(null, {
+						headers: response.headers,
+						status: response.status,
+						statusText: response.statusText
+					});
+				});
+			},
+			handleApi: (req, apiUrl, _ctx, stagedHeaders) => {
+				const transportedPolicyHeaders = withResponseStageVary(responseStagePolicyHeaders, stagedHeaders.get("Vary"));
+				const responseStageProps = () => ({
+					apiUrl,
+					buildId: pagesEntry.buildId,
+					cacheability: {
+						policyHeaders: transportedPolicyHeaders,
+						probeMode,
+						resolvedRoutePathname: new URL(apiUrl, req.url).pathname
+					},
+					kind: "pages-api",
+					protocolVersion: 4,
+					requestHost: new URL(req.url).host,
+					stagedHeaders: [...stagedHeaders]
+				});
+				const cache = forceCacheBypass || probeMode ? "bypass" : getPagesResponseStageCacheDisposition({
+					authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
+					request: req,
+					requestHeadersChanged: !haveSameHeaders(filteredHeaders, req.headers),
+					stagedHeaders
+				});
+				const dispatched = trackedDispatchResponseStage(req, responseStageProps(), { cache }, env, ctx);
+				return cache === "shared" ? dispatched.then((response) => {
+					sharedResponseHeaders = new Headers(response.headers);
+					sharedOuterPolicyHeaders = null;
+					return response;
+				}) : dispatched;
+			},
+			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase, resolvedUrl) => {
+				if (!assets) return false;
+				if (isImageOptimizationPath(requestPathname)) {
+					const imageUrl = new URL(resolvedUrl, request.url);
+					const imageRequest = new Request(imageUrl, request);
+					const allowedWidths = [...vinextConfig?.images?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...vinextConfig?.images?.imageSizes ?? DEFAULT_IMAGE_SIZES];
+					return handleConfiguredImageOptimization(imageRequest, (assetPath) => Promise.resolve(assets.fetch(new Request(new URL(assetPath, request.url)))), allowedWidths, imageConfig);
+				}
+				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, missingBuildAsset);
+			}
+		};
+		const result = await runPagesRequest(request, deps);
+		if (result.type === "response") {
+			let response = finalizeMissingStaticAssetResponse(result.response, missingBuildAsset);
+			if (sharedResponseHeaders && sharedOuterPolicyHeaders) reconcileCdnResponseHeadersAfterOuterPolicy(response.headers, sharedOuterPolicyHeaders);
+			if (probeMode && probeRoute && !responseStageDispatched) {
+				const { finalizeRequestStageCacheabilityProbe } = await import("./cacheability-request.js");
+				response = finalizeRequestStageCacheabilityProbe(response, {
+					mode: probeMode,
+					responseStageDispatched,
+					route: probeRoute
+				});
+			}
+			return response;
+		}
+		return missingBuildAsset ? notFoundStaticAssetResponse() : new Response("This page could not be found", { status: 404 });
+	} catch (error) {
+		console.error("[vinext] Worker error:", error);
+		return new Response("Internal Server Error", { status: 500 });
+	}
+}
+//#endregion
+export { handleRequestStage, handleRequestStageLocally, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret };

package/dist/server/pages-response-stage-entry.d.ts

@@ -0,0 +1,11 @@
+import { VinextRequestStageTransport, VinextResponseStageDispatchOptions } from "./multi-stage.js";
+import { ExecutionContextLike } from "../shims/request-context.js";
+import { WorkerResponseStageProps } from "./worker-stages.js";
+//#region src/server/pages-response-stage-entry.d.ts
+type PagesWorkerEnv = Record<string, unknown>;
+type PagesWorkerExecutionContext = ExecutionContextLike & {
+  cache?: unknown;
+};
+export declare function renderPagesResponse(request: Request, env: PagesWorkerEnv | undefined, platformCtx: PagesWorkerExecutionContext | undefined, props: WorkerResponseStageProps, stagedHeaders?: Headers, dispatchRequestStage?: VinextRequestStageTransport, dispatchOptions?: VinextResponseStageDispatchOptions): Promise<Response>;
+export declare function handleResponseStage(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined, props: WorkerResponseStageProps, dispatchRequestStage: VinextRequestStageTransport, options: VinextResponseStageDispatchOptions): Promise<Response>;
+//#endregion

package/dist/server/pages-response-stage-entry.js

@@ -0,0 +1,106 @@
+import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import "../shims/unified-request-context.js";
+import { runWithExecutionContext } from "../shims/request-context.js";
+import { beginRouteCacheability } from "../shims/cacheability-classification.js";
+import { validateCdnRequest } from "./cache-control.js";
+import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
+import { createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
+import { withResponseStageCacheability } from "./response-stage-cacheability.js";
+import { PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, isPagesResponseStageProps } from "./worker-stages.js";
+import { applyResponseStagePolicyHeaders, stripInheritedResponseStageCookies } from "./response-stage-policy.js";
+import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
+import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+import * as pagesEntry from "virtual:vinext-pages-response-entry";
+import __cacheabilityManifest from "virtual:vinext-cacheability-manifest";
+//#region src/server/pages-response-stage-entry.ts
+/** Cacheable Pages render/API stage. This is the only Pages Worker stage that imports user pages. */
+/** Remove a body length inherited from response staging before transport drops the stream tag. */
+function stripStreamedHtmlContentLength(response) {
+	if (response.__vinextStreamedHtmlResponse !== true || !response.headers.has("Content-Length")) return response;
+	try {
+		response.headers.delete("Content-Length");
+		return response;
+	} catch {
+		const headers = new Headers(response.headers);
+		headers.delete("Content-Length");
+		const stripped = preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		}));
+		stripped.__vinextStreamedHtmlResponse = true;
+		return stripped;
+	}
+}
+async function renderPagesResponse(request, env, platformCtx, props, stagedHeaders, dispatchRequestStage, dispatchOptions = { cache: "bypass" }) {
+	if (!isPagesResponseStageProps(props)) return new Response("Invalid vinext Pages response stage", { status: 400 });
+	if (props.buildId !== pagesEntry.buildId) return new Response("Vinext Pages response stage deployment mismatch", { status: 409 });
+	if (props.requestHost !== new URL(request.url).host) return new Response("Invalid vinext Pages response stage", { status: 400 });
+	await pagesEntry.__ensureInstrumentation?.();
+	registerConfiguredImageOptimizer(env);
+	const renderHeaders = new Headers(stagedHeaders ?? props.stagedHeaders ?? []);
+	renderHeaders.delete("Content-Length");
+	const initialResponseHeaders = new Headers(renderHeaders);
+	if (props.stagedHeaders === null && stagedHeaders === void 0) {
+		applyResponseStagePolicyHeaders(initialResponseHeaders, props.cacheability.policyHeaders);
+		applyResponseStagePolicyHeaders(renderHeaders, props.cacheability.policyHeaders);
+	}
+	let ctx = createWorkerRevalidationContext(platformCtx, (internalRequest) => {
+		if (!dispatchRequestStage) throw new Error("Pages response stage requires a request-stage dispatcher");
+		return dispatchRequestStage(internalRequest);
+	}, "node");
+	if (props.kind === "pages-prerender-discovery") ctx = {
+		...ctx,
+		isPrerenderPathDiscovery: true
+	};
+	const render = async (cacheabilityContext) => {
+		if (props.kind === "pages-prerender-discovery") {
+			const readinessResponse = createWorkerPrerenderReadinessResponse(cacheabilityContext, request);
+			if (readinessResponse) return await validateCdnRequest(request) ?? readinessResponse;
+			const { handleAppPrerenderEndpoint } = await import("./app-prerender-endpoints.js");
+			return await runWithExecutionContext(cacheabilityContext, () => handleAppPrerenderEndpoint(request, {
+				isPrerenderEnabled: () => true,
+				loadPagesRoutes: async () => pagesEntry.pageRoutes,
+				pathname: new URL(request.url).pathname,
+				staticParamsMap: {}
+			})) ?? new Response("This page could not be found", { status: 404 });
+		}
+		if (props.kind === "pages-api") {
+			if (typeof pagesEntry.handleApiRoute !== "function") return new Response("This page could not be found", { status: 404 });
+			return runWithExecutionContext(cacheabilityContext, () => {
+				beginRouteCacheability("pages-api", props.cacheability.resolvedRoutePathname);
+				return pagesEntry.handleApiRoute(request, props.apiUrl, cacheabilityContext, new URL(request.url).origin, cacheabilityContext.hostRuntime ?? "node", initialResponseHeaders);
+			});
+		}
+		if (typeof pagesEntry.renderPage !== "function") return new Response("This page could not be found", { status: 404 });
+		return stripStreamedHtmlContentLength(await pagesEntry.renderPage(request, props.resolvedUrl, null, cacheabilityContext, renderHeaders, props.renderOptions ?? void 0, initialResponseHeaders));
+	};
+	const handle = async (cacheabilityContext) => stripInheritedResponseStageCookies(await render(cacheabilityContext), renderHeaders);
+	const response = await withResponseStageCacheability({
+		buildId: pagesEntry.buildId,
+		cache: props.kind === "pages-prerender-discovery" ? "bypass" : dispatchOptions.cache,
+		context: ctx,
+		policyHeaders: props.cacheability.policyHeaders,
+		policyHeadersAppliedBeforeRender: true,
+		probeMode: props.cacheability.probeMode,
+		rawManifest: __cacheabilityManifest,
+		registerCacheAdapters: () => registerConfiguredCacheAdapters(env),
+		request,
+		representation: props.cacheability.representation,
+		resolvedRoutePathname: props.cacheability.resolvedRoutePathname
+	}, handle);
+	if (props.kind !== "pages-page") return response;
+	const runtimeDataKind = pagesEntry.getRuntimePageDataKind(props.resolvedUrl, request);
+	const headers = new Headers(response.headers);
+	headers.set(PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, runtimeDataKind === "server" || runtimeDataKind === "initial" ? "request-time" : "static");
+	return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	}));
+}
+function handleResponseStage(request, env, ctx, props, dispatchRequestStage, options) {
+	return renderPagesResponse(request, env, ctx, props, void 0, dispatchRequestStage, options);
+}
+//#endregion
+export { handleResponseStage, renderPagesResponse };

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

@@ -0,0 +1,31 @@
+import { VinextResponseStageDispatchOptions } from "./multi-stage.js";
+import { PagesRouteDataKind } from "./pages-route-data-kind.js";
+//#region src/server/pages-response-stage.d.ts
+export declare function hasPagesPreviewCookie(cookieHeader: string | null): boolean;
+export type PagesResponseStageDispatchOptions = {
+  authorizeOnDemandRevalidate?: (headerValue: string | null) => boolean;
+  /** A custom Document getInitialProps can observe the request/response pair. */
+  hasRequestAwareDocument?: boolean;
+  request: Request;
+  /** Middleware changed the request headers visible to the response stage. */
+  requestHeadersChanged?: boolean;
+  routeDataKind?: PagesRouteDataKind;
+  stagedHeaders?: Headers;
+};
+export type PagesResponseStageCacheDisposition = VinextResponseStageDispatchOptions["cache"];
+/**
+ * Whether a Pages response may be delegated to a shared response stage.
+ *
+ * Next.js does not construct a static response-cache key in draft mode and
+ * handles authenticated on-demand revalidation outside ordinary cache reuse.
+ * Non-idempotent methods need to reach the renderer, while CSP nonces are
+ * embedded in the rendered body. Request Cache-Control remains visible on a
+ * cache miss, but does not bypass an existing host-cache entry in production.
+ *
+ * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/route-modules/pages/pages-handler.ts
+ * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/base-server.ts
+ */
+export declare function shouldDispatchPagesResponseStage({ authorizeOnDemandRevalidate, hasRequestAwareDocument, request, requestHeadersChanged, routeDataKind, stagedHeaders }: PagesResponseStageDispatchOptions): boolean;
+/** Decide whether a host response-stage transport may share the rendered response. */
+export declare function getPagesResponseStageCacheDisposition(options: PagesResponseStageDispatchOptions): PagesResponseStageCacheDisposition;
+//#endregion

package/dist/server/pages-response-stage.js

@@ -0,0 +1,49 @@
+import { MIDDLEWARE_SET_COOKIE_HEADER, PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
+import "./headers.js";
+import { getScriptNonceFromHeaderSources } from "./csp.js";
+//#region src/server/pages-response-stage.ts
+const PREVIEW_COOKIE_NAMES = /* @__PURE__ */ new Set(["__prerender_bypass", "__next_preview_data"]);
+function hasPagesPreviewCookie(cookieHeader) {
+	if (!cookieHeader) return false;
+	for (const pair of cookieHeader.split(";")) {
+		const separator = pair.indexOf("=");
+		const name = (separator === -1 ? pair : pair.slice(0, separator)).trim();
+		if (PREVIEW_COOKIE_NAMES.has(name)) return true;
+	}
+	return false;
+}
+function hasStagedCacheBypass(stagedHeaders) {
+	return stagedHeaders?.has(MIDDLEWARE_SET_COOKIE_HEADER) === true;
+}
+/**
+* Whether a Pages response may be delegated to a shared response stage.
+*
+* Next.js does not construct a static response-cache key in draft mode and
+* handles authenticated on-demand revalidation outside ordinary cache reuse.
+* Non-idempotent methods need to reach the renderer, while CSP nonces are
+* embedded in the rendered body. Request Cache-Control remains visible on a
+* cache miss, but does not bypass an existing host-cache entry in production.
+*
+* @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/route-modules/pages/pages-handler.ts
+* @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/base-server.ts
+*/
+function shouldDispatchPagesResponseStage({ authorizeOnDemandRevalidate, hasRequestAwareDocument, request, requestHeadersChanged, routeDataKind, stagedHeaders }) {
+	const method = request.method.toUpperCase();
+	if (method !== "GET" && method !== "HEAD") return false;
+	if (request.headers.get("upgrade")?.split(",").some((value) => value.trim().toLowerCase() === "websocket")) return false;
+	if (hasRequestAwareDocument && routeDataKind === "static") return false;
+	if (hasPagesPreviewCookie(request.headers.get("cookie"))) return false;
+	if (requestHeadersChanged) return false;
+	if (hasStagedCacheBypass(stagedHeaders)) return false;
+	const revalidateHeader = request.headers.get(PRERENDER_REVALIDATE_HEADER);
+	if (authorizeOnDemandRevalidate?.(revalidateHeader) === true) return false;
+	return getScriptNonceFromHeaderSources(request.headers, stagedHeaders) === void 0;
+}
+/** Decide whether a host response-stage transport may share the rendered response. */
+function getPagesResponseStageCacheDisposition(options) {
+	const revalidateHeader = options.request.headers.get(PRERENDER_REVALIDATE_HEADER);
+	if (options.authorizeOnDemandRevalidate?.(revalidateHeader) === true) return "bypass";
+	return shouldDispatchPagesResponseStage(options) ? "shared" : "bypass";
+}
+//#endregion
+export { getPagesResponseStageCacheDisposition, hasPagesPreviewCookie, shouldDispatchPagesResponseStage };

package/dist/server/pages-revalidate.d.ts

@@ -1,6 +1,6 @@
 import { IncomingMessage } from "node:http";
 //#region src/server/pages-revalidate.d.ts
-type RevalidateOptions = {
+export type RevalidateOptions = {
   /**
    * Only revalidate the path if it was already generated (cached). Mirrors
    * Next.js's `unstable_onlyGenerated`: sets the
@@ -9,6 +9,5 @@ type RevalidateOptions = {
    */
   unstable_onlyGenerated?: boolean;
 };
-declare function performOnDemandRevalidate(source: IncomingMessage | Headers, urlPath: string, opts?: RevalidateOptions, trustedOrigin?: string, allowedRevalidateHeaderKeys?: readonly string[], dev?: boolean): Promise<void>;
-//#endregion
-export { RevalidateOptions, performOnDemandRevalidate };
+export declare function performOnDemandRevalidate(source: IncomingMessage | Headers, urlPath: string, opts?: RevalidateOptions, trustedOrigin?: string, allowedRevalidateHeaderKeys?: readonly string[], dev?: boolean): Promise<void>;
+//#endregion

package/dist/server/pages-revalidate.js

@@ -1,8 +1,10 @@
-import { getRequestExecutionContext } from "../shims/request-context.js";
 import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
-import "./headers.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { VINEXT_REVALIDATED_CACHE_TAG_HEADER } from "./headers.js";
 import { normalizeDomainHostname } from "../utils/domain-locale.js";
-import { getRevalidateSecret, isOnDemandRevalidateRequest } from "./isr-cache.js";
+import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
+import { getRevalidateSecret, isOnDemandRevalidateRequest } from "./revalidation-request.js";
+import "./isr-cache.js";
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 //#region src/server/pages-revalidate.ts
 async function performOnDemandRevalidate(source, urlPath, opts = {}, trustedOrigin, allowedRevalidateHeaderKeys = [], dev = false) {
@@ -26,6 +28,8 @@ async function performOnDemandRevalidate(source, urlPath, opts = {}, trustedOrig
 	if (dispatchRevalidate && executionContext.isInternalPagesRevalidation) throw new Error(`Cannot revalidate ${urlPath} from an internal revalidation request`);
 	const res = await fetchRevalidateTarget(target, headers, dispatchRevalidate);
 	if (!((res.headers.get("x-vercel-cache") ?? res.headers.get("x-nextjs-cache"))?.toUpperCase() === "REVALIDATED" || res.status === 200 || res.status === 404 && opts.unstable_onlyGenerated === true)) throw new Error(`Failed to revalidate ${urlPath}: ${res.status}`);
+	const regeneratedTag = res.headers.get(VINEXT_REVALIDATED_CACHE_TAG_HEADER);
+	if (regeneratedTag) await getCdnCacheAdapter().revalidateTag(regeneratedTag);
 }
 function readSourceHeader(source, key) {
 	if (isWebHeaders(source)) return source.get(key) ?? void 0;
@@ -33,7 +37,8 @@ function readSourceHeader(source, key) {
 	return Array.isArray(value) ? value.join(", ") : value;
 }
 function isSourceRevalidationRequest(source) {
-	return isOnDemandRevalidateRequest(isWebHeaders(source) ? source.get(PRERENDER_REVALIDATE_HEADER) : source.headers[PRERENDER_REVALIDATE_HEADER]);
+	const headerValue = isWebHeaders(source) ? source.get(PRERENDER_REVALIDATE_HEADER) : source.headers[PRERENDER_REVALIDATE_HEADER];
+	return isOnDemandRevalidateRequest(headerValue);
 }
 function isWebHeaders(source) {
 	return typeof source.get === "function";

package/dist/server/pages-route-data-kind.d.ts

@@ -0,0 +1,18 @@
+//#region src/server/pages-route-data-kind.d.ts
+export type RuntimePagesDataKind = "initial" | "none" | "server" | "static";
+/** Build-time classification available before a Pages module is loaded. */
+export type PagesRouteDataKind = Exclude<RuntimePagesDataKind, "initial">;
+type PagesModule = {
+  default?: {
+    getInitialProps?: unknown;
+  };
+  getServerSideProps?: unknown;
+  getStaticProps?: unknown;
+};
+type AppComponent = {
+  getInitialProps?: unknown;
+  origGetInitialProps?: unknown;
+} | null;
+/** Classify loaded Pages modules after HOCs and re-exports have been evaluated. */
+export declare function getRuntimePagesDataKind(pageModule: PagesModule, appComponent: AppComponent): RuntimePagesDataKind;
+//#endregion

package/dist/server/pages-route-data-kind.js

@@ -0,0 +1,11 @@
+//#region src/server/pages-route-data-kind.ts
+/** Classify loaded Pages modules after HOCs and re-exports have been evaluated. */
+function getRuntimePagesDataKind(pageModule, appComponent) {
+	if (typeof pageModule.getStaticProps === "function") return "static";
+	if (typeof pageModule.getServerSideProps === "function") return "server";
+	if (typeof pageModule.default?.getInitialProps === "function") return "initial";
+	if (typeof appComponent?.getInitialProps === "function" && appComponent.getInitialProps !== appComponent.origGetInitialProps) return "initial";
+	return "none";
+}
+//#endregion
+export { getRuntimePagesDataKind };

package/dist/server/pages-router-entry.d.ts

@@ -1,29 +1,5 @@
+import { PagesWorkerEnv, PagesWorkerExecutionContext } from "./pages-request-stage-entry.js";
 //#region src/server/pages-router-entry.d.ts
-/**
- * Router-specific Cloudflare Worker entry point for vinext Pages Router.
- *
- * New projects should usually use the router-selected entry in wrangler.jsonc:
- *   "main": "vinext/server/fetch-handler"
- *
- * This Pages Router entry remains available for existing configs and for custom
- * workers that need to opt into the Pages Router handler explicitly:
- *   "main": "vinext/server/pages-router-entry"
- *
- * Or import and delegate to it from a custom worker:
- *   import handler from "vinext/server/pages-router-entry";
- *   return handler.fetch(request, env, ctx);
- */
-type AssetFetcher = {
-  fetch(request: Request): Promise<Response> | Response;
-};
-type PagesWorkerEnv = {
-  ASSETS?: AssetFetcher;
-} & Record<string, unknown>;
-type PagesWorkerExecutionContext = {
-  waitUntil?(promise: Promise<unknown>): void;
-  passThroughOnException?(): void;
-  cache?: unknown;
-};
 declare const _default: {
   fetch(request: Request, env?: PagesWorkerEnv, ctx?: PagesWorkerExecutionContext): Promise<Response>;
 };