vinext 1.0.1 → 1.2.0

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

@@ -6,17 +6,19 @@ 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 { attachRequestCfMetadata, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { isNextDataPathname } from "./pages-data-route.js";
 import { getExplicitCdnCacheAdapter } from "../shims/cdn-cache-state.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 { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath, isImageSourceBodyStatus } from "./image-optimization.js";
 import { traceFrameworkRequest } from "./request-tracing.js";
 import { resolveResponseStageCachePolicy } from "./config-headers.js";
+import { createStaticAssetRequest } from "./worker-utils.js";
 import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
+import { resolveClientBuildFile } from "./client-build-files.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse, isWorkerPrerenderDiscoveryPath } from "./worker-prerender-discovery.js";
 import { getPagesResponseStageCacheDisposition } from "./pages-response-stage.js";
@@ -40,12 +42,13 @@ function haveSameHeaders(first, second) {
 function captureOuterResponsePolicyHeaders(stagedHeaders, transportedPolicyHeaders) {
 	return captureCdnResponsePolicyOverrides(stagedHeaders, new Headers(transportedPolicyHeaders ?? []));
 }
-const { authorizeOnDemandRevalidate, hasMiddleware, hasRequestAwareDocument, matchApiRoute, matchPageRoute, normalizeDataRequest, publicFiles, runMiddleware, vinextConfig } = pagesEntry;
+const { authorizeOnDemandRevalidate, hasMiddleware, hasRequestAwareDocument, matchApiRoute, matchPageRoute, normalizeDataRequest, publicFiles, clientBuildFiles, 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 skipTrailingSlashRedirect = vinextConfig?.skipTrailingSlashRedirect ?? false;
 const i18nConfig = vinextConfig?.i18n ?? null;
 const configRedirects = vinextConfig?.redirects ?? [];
 const configRewrites = vinextConfig?.rewrites ?? {
@@ -61,6 +64,17 @@ const imageConfig = vinextConfig?.images ? {
 	contentDispositionType: vinextConfig.images.contentDispositionType,
 	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
 } : void 0;
+/**
+* Whether the request stage serves this request as a client build file
+* outside `_next/static`. Such responses resolve no route, so the Worker
+* keeps their ASSETS cache policy out of route cacheability admission.
+*/
+function isPagesClientBuildFileRequest(request, env, ctx) {
+	return (request.method === "GET" || request.method === "HEAD") && resolveAssetFetcher(ctx?.assets, env, "worker") !== void 0 && resolveClientBuildFile(new URL(request.url).pathname, basePath, clientBuildFiles) !== null;
+}
+function resolveAssetFetcher(assets, env, defaultHostRuntime) {
+	return assets ?? getExplicitCdnCacheAdapter()?.assets ?? (defaultHostRuntime === "worker" ? env?.ASSETS : void 0);
+}
 /** Run the request-time stage with a host-owned response dispatcher. */
 function handleRequestStage(request, env, ctx, dispatchResponseStage) {
 	const originalRequest = request;
@@ -90,7 +104,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 	let sharedOuterPolicyHeaders = null;
 	let ctx = createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets), defaultHostRuntime);
 	configuredCdnCacheAdapters.registerConfiguredCacheAdapters(env);
-	assets ??= getExplicitCdnCacheAdapter()?.assets ?? (defaultHostRuntime === "worker" ? env?.ASSETS : void 0);
+	assets = resolveAssetFetcher(assets, env, defaultHostRuntime);
 	if (configuredCdnCacheAdapters.hasConfiguredDataCache) registerLazyDataCacheHandler(async () => {
 		(await import("virtual:vinext-cache-adapters")).registerConfiguredCacheAdapters(env);
 	});
@@ -144,16 +158,21 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 				resolvedRoutePathname: pathname
 			},
 			kind: "pages-prerender-discovery",
-			protocolVersion: 4,
+			protocolVersion: 5,
 			requestHost: url.host,
 			stagedHeaders: null
 		}, { cache: "bypass" }, env, ctx);
-		if (isOpenRedirectShaped(pathname)) return new Response("This page could not be found", { status: 404 });
+		const protocolRelativeGuard = guardProtocolRelativeUrl(pathname, url.search);
+		if (protocolRelativeGuard) return protocolRelativeGuard;
 		try {
 			normalizePathnameForRouteMatchStrict(pathname);
 		} catch {
 			return new Response("Bad Request", { status: 400 });
 		}
+		if (assets && (request.method === "GET" || request.method === "HEAD")) {
+			const clientBuildFile = resolveClientBuildFile(pathname, basePath, clientBuildFiles);
+			if (clientBuildFile) return await assets.fetch(createStaticAssetRequest(clientBuildFile, request));
+		}
 		const missingBuildAsset = isNextStaticPath(pathname, basePath, assetPathPrefix);
 		const hadBasePath = !basePath || hasBasePath(pathname, basePath);
 		{
@@ -166,6 +185,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			}
 		}
 		const middlewareRequest = request;
+		const originalRenderUrl = pathname + new URL(request.url).search;
 		const dataNorm = normalizeDataRequest(request);
 		if (dataNorm.notFoundResponse && !vinextConfig?.skipProxyUrlNormalize) return dataNorm.notFoundResponse;
 		const isDataReq = dataNorm.isDataReq;
@@ -188,6 +208,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			assetPrefix: vinextConfig?.assetPrefix,
 			basePath,
 			trailingSlash,
+			skipTrailingSlashRedirect,
 			i18nConfig,
 			configRedirects,
 			configRewrites,
@@ -227,9 +248,12 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(resolvedUrl, req.url).pathname
 					},
 					kind: "pages-page",
-					protocolVersion: 4,
+					protocolVersion: 5,
 					requestHost: new URL(req.url).host,
-					renderOptions: options ?? null,
+					renderOptions: isDataReq ? {
+						...options,
+						originalUrl: originalRenderUrl
+					} : options ?? null,
 					resolvedUrl,
 					stagedHeaders: isSharedStaticPage ? null : [...stagedHeaders ?? new Headers()]
 				});
@@ -264,7 +288,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(apiUrl, req.url).pathname
 					},
 					kind: "pages-api",
-					protocolVersion: 4,
+					protocolVersion: 5,
 					requestHost: new URL(req.url).host,
 					stagedHeaders: [...stagedHeaders]
 				});
@@ -281,17 +305,56 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 					return response;
 				}) : dispatched;
 			},
-			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase, resolvedUrl) => {
+			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase, resolvedUrl, filesystemRequest, resolvedPathnameHasBasePath) => {
 				if (!assets) return false;
-				if (isImageOptimizationPath(requestPathname)) {
+				if (resolvedPathnameHasBasePath && isImageOptimizationPath(requestPathname)) {
 					const imageUrl = new URL(resolvedUrl, request.url);
-					const imageRequest = new Request(imageUrl, request);
+					const imageRequest = cloneRequestWithUrl(request, imageUrl.href);
 					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);
+					const { fetchWorkerImageSource } = await import("./worker-image-optimization.js");
+					return handleConfiguredImageOptimization(imageRequest, (sourceUrl, sourceImageRequest) => fetchWorkerImageSource(sourceUrl, sourceImageRequest, {
+						assets,
+						basePath,
+						assetPathPrefix,
+						clientBuildFiles,
+						fetchPublicFile: (sourceRequest) => resolvePublicImageSource(sourceRequest, assets)
+					}), allowedWidths, imageConfig);
 				}
-				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix);
+				return fetchWorkerFilesystemRoute(filesystemRequest, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, hadBasePath);
 			}
 		};
+		const resolvePublicImageSource = async (sourceRequest, sourceAssets) => {
+			const sourceUrl = new URL(sourceRequest.url);
+			if (guardProtocolRelativeUrl(sourceUrl.pathname, sourceUrl.search)) return null;
+			const sourceHadBasePath = !basePath || hasBasePath(sourceUrl.pathname, basePath);
+			const sourcePathname = stripBasePath(sourceUrl.pathname, basePath);
+			if (isNextDataPathname(sourcePathname)) return null;
+			let sourceAsset = null;
+			const sourceResult = await runPagesRequest(attachRequestCfMetadata(new Request(new URL(sourcePathname + sourceUrl.search, sourceUrl), { signal: sourceRequest.signal }), sourceRequest), {
+				...deps,
+				hadBasePath: sourceHadBasePath,
+				isDataReq: false,
+				isDataRequest: false,
+				middlewareRequest: void 0,
+				dataNotFoundResponse: null,
+				recordCacheability: false,
+				runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, sourceHadBasePath) : null,
+				renderPage: null,
+				handleApi: null,
+				serveFilesystemRoute: async (candidate, _stagedHeaders, phase, _resolvedUrl, filesystemRequest) => {
+					if (isImageOptimizationPath(candidate)) return false;
+					const asset = await fetchWorkerFilesystemRoute(filesystemRequest, candidate, phase, (assetRequest) => Promise.resolve(sourceAssets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, sourceHadBasePath);
+					if (asset === false) return false;
+					sourceAsset = asset;
+					return new Response(null);
+				}
+			});
+			if (sourceResult.type !== "response") return null;
+			await sourceResult.response.body?.cancel().catch(() => {});
+			if (isImageSourceBodyStatus(sourceResult.response.status)) return sourceAsset;
+			await sourceAsset?.body?.cancel().catch(() => {});
+			return null;
+		};
 		const result = await runPagesRequest(request, deps);
 		if (result.type === "response") {
 			let response = result.response;
@@ -313,4 +376,4 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 	}
 }
 //#endregion
-export { handleRequestStage, handleRequestStageLocally, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret };
+export { handleRequestStage, handleRequestStageLocally, isPagesClientBuildFileRequest, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret };

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

@@ -53,6 +53,10 @@ async function renderPagesResponse(request, env, platformCtx, props, stagedHeade
 		...ctx,
 		isPrerenderPathDiscovery: true
 	};
+	else if (props.kind === "pages-page" && dispatchOptions.regeneratesStoredEntry === true) ctx = {
+		...ctx,
+		isStoredEntryRegeneration: true
+	};
 	const render = async (cacheabilityContext) => {
 		if (props.kind === "pages-prerender-discovery") {
 			const readinessResponse = createWorkerPrerenderReadinessResponse(cacheabilityContext, request);

package/dist/server/pages-revalidate.js

@@ -29,7 +29,7 @@ async function performOnDemandRevalidate(source, urlPath, opts = {}, trustedOrig
 	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);
+	if (regeneratedTag) await getCdnCacheAdapter().revalidateTag(decodeURIComponent(regeneratedTag));
 }
 function readSourceHeader(source, key) {
 	if (isWebHeaders(source)) return source.get(key) ?? void 0;

package/dist/server/pages-router-entry.js

@@ -5,7 +5,7 @@ import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { validateCdnRequest } from "./cache-control.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
-import { handleRequestStageLocally, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret } from "./pages-request-stage-entry.js";
+import { handleRequestStageLocally, isPagesClientBuildFileRequest, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret } from "./pages-request-stage-entry.js";
 import { renderPagesResponse } from "./pages-response-stage-entry.js";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 import { __ensureInstrumentation } from "virtual:vinext-pages-request-entry";
@@ -23,8 +23,9 @@ async function handleSingleStageRequest(request, env, platformCtx) {
 		if (readinessResponse.status === 204) await Promise.all([__ensureInstrumentation(), __ensureInstrumentation$1()]);
 		return await validateCdnRequest(request) ?? readinessResponse;
 	}
+	const isClientBuildFile = isPagesClientBuildFileRequest(request, env, ctx);
 	let finalize;
-	if (request.headers.has("X-Vinext-Cacheability-Probe")) {
+	if (!isClientBuildFile && request.headers.has("X-Vinext-Cacheability-Probe")) {
 		const cacheability = await import("./cacheability-request.js");
 		const probeContext = cacheability.createWorkerCacheabilityContext(ctx, request, pagesRequestStagePrerenderSecret, adapter.responseVary);
 		if (probeContext !== ctx) {
@@ -39,7 +40,7 @@ async function handleSingleStageRequest(request, env, platformCtx) {
 		}
 	}
 	const requiresCompletedResponseAdmission = adapter.requiresCompletedResponseAdmission === true;
-	if (!finalize && (__cacheabilityManifest || requiresCompletedResponseAdmission)) {
+	if (!finalize && !isClientBuildFile && (__cacheabilityManifest || requiresCompletedResponseAdmission)) {
 		const cacheability = await import("./cacheability-request.js");
 		const admissionContext = cacheability.createWorkerCacheabilityAdmissionContext(ctx, request, __cacheabilityManifest, pagesRequestStageBuildId, requiresCompletedResponseAdmission, adapter.responseVary);
 		if (admissionContext !== ctx) {

package/dist/server/prerender-manifest.d.ts

@@ -32,7 +32,6 @@ export type PrerenderManifest = {
   pregeneratedConcretePaths?: Array<[string, string[]]>;
 };
 export type PrerenderedPathSelectionOptions = {
-  includeFallbackShells?: boolean;
   includeErrorDocuments?: boolean;
 };
 export declare function readPrerenderManifest(manifestPath: string): PrerenderManifest | null;
@@ -58,8 +57,9 @@ export declare function buildPregeneratedConcretePathTable(manifest: PrerenderMa
  * This intentionally includes both App Router and Pages Router entries because
  * deploy-time cache warmup should exercise the same URLs the prerender phase
  * proved are statically renderable. PPR fallback-shell placeholder artifacts
- * and known error documents are excluded by default so warmup does not request
- * synthetic bracket paths or treat a healthy 404 response as a failed warmup.
+ * are always excluded, and known error documents by default, so warmup does not
+ * request synthetic bracket paths or treat a healthy 404 response as a failed
+ * warmup.
  */
 export declare function getPrerenderedConcretePaths(manifest: PrerenderManifest, options?: PrerenderedPathSelectionOptions): string[];
 //#endregion

package/dist/server/prerender-manifest.js

@@ -65,8 +65,9 @@ function buildPregeneratedConcretePathTable(manifest) {
 * This intentionally includes both App Router and Pages Router entries because
 * deploy-time cache warmup should exercise the same URLs the prerender phase
 * proved are statically renderable. PPR fallback-shell placeholder artifacts
-* and known error documents are excluded by default so warmup does not request
-* synthetic bracket paths or treat a healthy 404 response as a failed warmup.
+* are always excluded, and known error documents by default, so warmup does not
+* request synthetic bracket paths or treat a healthy 404 response as a failed
+* warmup.
 */
 function getPrerenderedConcretePaths(manifest, options) {
 	const routes = manifest.routes;
@@ -76,7 +77,7 @@ function getPrerenderedConcretePaths(manifest, options) {
 	for (const route of routes) {
 		if (route.status !== "rendered" || route.notFound) continue;
 		const pathname = route.path ?? route.route;
-		if (!options?.includeFallbackShells && isFallbackShellArtifactPath(pathname, route)) continue;
+		if (isFallbackShellArtifactPath(pathname, route)) continue;
 		if (!options?.includeErrorDocuments && isErrorDocumentRoute(pathname, route)) continue;
 		if (seen.has(pathname)) continue;
 		seen.add(pathname);

package/dist/server/prerender-work-unit-setup.js

@@ -1,3 +1,4 @@
+import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { workUnitAsyncStorage } from "../shims/internal/work-unit-async-storage.js";
 import { isRouteCacheabilityProbe } from "../shims/cacheability-classification.js";
 import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
@@ -15,6 +16,9 @@ import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
 *
 */
 function runWithPrerenderWorkUnit(fn, options) {
+	return runInWorkStoreScope(() => runWithWorkUnit(fn, options));
+}
+function runWithWorkUnit(fn, options) {
 	if (process.env.VINEXT_PRERENDER === "1" || isRouteCacheabilityProbe()) {
 		if (options?.cacheComponents !== true) return workUnitAsyncStorage.run({ type: "prerender-legacy" }, fn);
 		return runWithPrerenderWorkUnitOwner(fn, options);

package/dist/server/prod-server.d.ts

@@ -2,6 +2,7 @@ import { NextI18nConfig } from "../config/next-config.js";
 import { negotiateEncoding } from "./accept-encoding.js";
 import { StaticFileCache } from "./static-file-cache.js";
 import { resolveRequestHost, trustProxy, trustedHosts } from "./proxy-trust.js";
+import { COMPRESS_THRESHOLD, isCompressibleContentType } from "./response-compression.js";
 import { IncomingMessage, ServerResponse } from "node:http";
 //#region src/server/prod-server.d.ts
 /**
@@ -68,10 +69,6 @@ export type ProdServerOptions = {
   /** Suppress the startup log for internal child-process servers. */
   silent?: boolean;
 };
-/** Content types that benefit from compression. */
-declare const COMPRESSIBLE_TYPES: Set<string>;
-/** Minimum size threshold for compression (in bytes). Below this, compression overhead isn't worth it. */
-declare const COMPRESS_THRESHOLD = 1024;
 /**
  * Merge middleware headers and a Web Response's headers into a single
  * record suitable for Node.js `res.writeHead()`. Uses `getSetCookie()`
@@ -104,15 +101,19 @@ declare function sendCompressed(req: IncomingMessage, res: ServerResponse, body:
  *
  * Without a cache, falls back to async filesystem probing (still non-blocking,
  * unlike the old sync existsSync/statSync approach).
+ *
+ * `extraHeaders` go on every response for the file. `representationHeaders` go
+ * only on responses that carry the file's bytes (200 and 206), never on a 304,
+ * 412, 416 or 405.
  */
-declare function tryServeStatic(req: IncomingMessage, res: ServerResponse, clientDir: string, pathname: string, compress: boolean, cache?: StaticFileCache, extraHeaders?: Record<string, string | string[]>, statusCode?: number): Promise<boolean>;
+declare function tryServeStatic(req: IncomingMessage, res: ServerResponse, clientDir: string, pathname: string, compress: boolean, cache?: StaticFileCache, extraHeaders?: Record<string, string | string[]>, statusCode?: number, representationHeaders?: Record<string, string>): Promise<boolean>;
 /**
  * Convert a Node.js IncomingMessage to a Web Request object.
  *
  * When `urlOverride` is provided, it is used as the path + query string
  * instead of `req.url`.
  */
-declare function nodeToWebRequest(req: IncomingMessage, urlOverride?: string, prerenderSecret?: string, i18nConfig?: NextI18nConfig | null, authorizeOnDemandRevalidate?: (headerValue: string | null) => boolean): Request;
+declare function nodeToWebRequest(req: IncomingMessage, urlOverride?: string, prerenderSecret?: string, i18nConfig?: NextI18nConfig | null, authorizeOnDemandRevalidate?: (headerValue: string | null) => boolean, signal?: AbortSignal): Request;
 /**
  * Stream a Web Response back to a Node.js ServerResponse.
  * Supports streaming compression for SSR responses.
@@ -154,5 +155,17 @@ export declare function resolveAppRouterPrerenderSeeder(entryModule: unknown): A
  *    route through; the on-disk path is just `_next/static/...`.
  */
 export declare function resolveAppRouterAssetPath(pathname: string, assetPathPrefix: string, assetPrefix: string): string | null;
+/**
+ * Create the Pages Router request handler for `vite preview`. Vite's preview
+ * middleware (proxy, compression, `base`, static files) runs first, so this
+ * handles only the requests Vite doesn't serve and leaves compression to Vite.
+ * Resolves to null when the build has no Pages Router server entry.
+ */
+export declare function createPagesPreviewHandler(options: {
+  clientDir: string;
+  serverDir: string;
+  host: string;
+  port: number;
+}): Promise<((req: IncomingMessage, res: ServerResponse) => void) | null>;
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, trustProxy, trustedHosts, tryServeStatic, waitForNodeResponseCompletion };
+export { COMPRESS_THRESHOLD, isCompressibleContentType, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, trustProxy, trustedHosts, tryServeStatic, waitForNodeResponseCompletion };