vinext 1.0.1 → 1.2.0

package/dist/server/prod-server.js

@@ -5,18 +5,20 @@ import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from
 import { StaticFileCache, contentTypeForPath, etagFromFilenameHash } from "./static-file-cache.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
-import { VINEXT_PRERENDER_RENDER_ERROR_HEADER } from "./headers.js";
+import { VINEXT_PRERENDER_RENDER_ERROR_HEADER, VINEXT_PRERENDER_SPECIAL_ERROR_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { isOpenRedirectShaped } from "./open-redirect.js";
+import { getRepeatedSlashRedirect, isOpenRedirectShaped, sendRepeatedSlashRedirect } from "./open-redirect.js";
 import { readStaticFileSignal } from "./static-file-signal.js";
 import { canonicalizeRequestPathname, filterInternalHeaders } from "./request-pipeline.js";
+import { buildNextDataNotFoundResponse, encodeUrlParserIgnoredCharacters, isNextDataPathname, normalizeNextDataPagePathname, parseNextDataPathname, shouldAddTrailingSlashToPagesDataPath, urlParserCreatesPagesDataPath } from "./pages-data-route.js";
+import { buildCacheStateHeaders } from "./cache-headers.js";
 import { parseHttpDate } from "./http-date.js";
 import { evaluateStaticPreconditions } from "./http-conditional.js";
-import { buildNextDataNotFoundResponse, encodeUrlParserIgnoredCharacters, isNextDataPathname, normalizeNextDataPagePathname, parseNextDataPathname, shouldAddTrailingSlashToPagesDataPath, urlParserCreatesPagesDataPath } from "./pages-data-route.js";
 import { setPagesClientAssets } from "./pages-client-assets.js";
 import { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts } from "./proxy-trust.js";
-import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, isSafeImageContentType, parseImageParams } from "./image-optimization.js";
+import { signalFromNodeResponse } from "./node-response-signal.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_RESPONSE_CACHE_STATE, INVALID_IMAGE_SOURCE_MESSAGE, isImageOptimizationPath, isImageSourceBodyStatus, isSafeImageContentType, parseImageParams, readImageOptimizationSignal } from "./image-optimization.js";
 import { installSocketErrorBackstop } from "./socket-error-backstop.js";
 import { collectInlineCssManifest } from "../build/inline-css.js";
 import { readTrustedRevalidationHostname } from "./revalidation-host.js";
@@ -24,11 +26,13 @@ import { traceFrameworkRequest } from "./request-tracing.js";
 import { mergeHeaders } from "./worker-utils.js";
 import { runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
 import { computeClientRuntimeMetadata } from "../utils/client-runtime-metadata.js";
-import { readPrerenderSecret } from "../build/server-manifest.js";
+import { readPrerenderSecret, readServerCompress } from "../build/server-manifest.js";
 import { readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { resolveClientBuildFile } from "./client-build-files.js";
 import { registerPrerenderCloudflareLoader } from "../build/prerender-cloudflare-loader.js";
 import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
 import { negotiateEncoding, parseAcceptedEncodings, selectContentEncoding } from "./accept-encoding.js";
+import { COMPRESS_THRESHOLD, hasNoTransform, isCompressibleContentType, parseContentLengthHeader, resolveResponseCompression } from "./response-compression.js";
 import { ifRangeAllowsRange, parseByteRange } from "./http-range.js";
 import { createRequire } from "node:module";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -192,25 +196,6 @@ function readNodeStream(req) {
 		}
 	});
 }
-/** Content types that benefit from compression. */
-const COMPRESSIBLE_TYPES = /* @__PURE__ */ new Set([
-	"text/html",
-	"text/css",
-	"text/plain",
-	"text/xml",
-	"text/javascript",
-	"application/javascript",
-	"application/json",
-	"application/xml",
-	"application/xhtml+xml",
-	"application/rss+xml",
-	"application/atom+xml",
-	"image/svg+xml",
-	"application/manifest+json",
-	"application/wasm"
-]);
-/** Minimum size threshold for compression (in bytes). Below this, compression overhead isn't worth it. */
-const COMPRESS_THRESHOLD = 1024;
 /**
 * Create a compression stream for the given encoding.
 */
@@ -276,12 +261,14 @@ const NO_BODY_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
 	205,
 	304
 ]);
+const IMAGE_REPRESENTATION_HEADERS = buildCacheStateHeaders(IMAGE_RESPONSE_CACHE_STATE);
 const OMIT_BODY_HEADERS = /* @__PURE__ */ new Set(["content-length", "content-type"]);
 const OMIT_STATIC_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
 	"content-encoding",
 	"content-length",
 	"content-range",
-	"content-type"
+	"content-type",
+	VINEXT_PRERENDER_SPECIAL_ERROR_HEADER
 ]);
 function omitHeadersCaseInsensitive(headersRecord, targets) {
 	const filtered = {};
@@ -291,6 +278,23 @@ function omitHeadersCaseInsensitive(headersRecord, targets) {
 	}
 	return filtered;
 }
+function readHeaderCaseInsensitive(headersRecord, name) {
+	const key = Object.keys(headersRecord).find((entry) => entry.toLowerCase() === name);
+	if (key === void 0) return void 0;
+	const value = headersRecord[key];
+	return Array.isArray(value) ? value.join(", ") : value;
+}
+/** Remove one field name from a Vary header, dropping the header if it empties. */
+function omitVaryToken(headers, token) {
+	const varyKey = Object.keys(headers).find((key) => key.toLowerCase() === "vary");
+	if (varyKey === void 0) return headers;
+	const rawVary = headers[varyKey];
+	const remaining = (Array.isArray(rawVary) ? rawVary.join(",") : rawVary).split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0 && entry.toLowerCase() !== token.toLowerCase());
+	const result = { ...headers };
+	delete result[varyKey];
+	if (remaining.length > 0) result[varyKey] = remaining.join(", ");
+	return result;
+}
 function mergeVaryHeader(headers, value) {
 	const merged = { ...headers };
 	const existingKey = Object.keys(merged).find((key) => key.toLowerCase() === "vary");
@@ -332,10 +336,41 @@ function installClientBuildManifestGlobals(clientDir, assetBase, assetPrefix, cr
 function isNoBodyResponseStatus(status) {
 	return NO_BODY_RESPONSE_STATUSES.has(status);
 }
-function cancelResponseBody(response) {
+/**
+* Discard a response body nobody will read. When the client is gone, pass the
+* request signal's reason: React reports a reasonless cancel of a pending
+* render as a server error, but recognizes `ResponseAborted` as a disconnect.
+*/
+function cancelResponseBody(response, reason) {
 	const body = response.body;
 	if (!body || body.locked) return;
-	body.cancel().catch(() => {});
+	body.cancel(reason).catch(() => {});
+}
+/**
+* Buffer a response body, cancelling it if the client disconnects first so a
+* stalled stream does not outlive the connection. Resolves null when aborted.
+*/
+async function bufferResponseBodyUntilAborted(response, signal) {
+	const body = response.body;
+	if (!body) return Buffer.alloc(0);
+	const reader = body.getReader();
+	const cancel = () => {
+		reader.cancel(signal.reason).catch(() => {});
+	};
+	if (signal.aborted) cancel();
+	else signal.addEventListener("abort", cancel, { once: true });
+	const chunks = [];
+	try {
+		while (true) {
+			const result = await reader.read();
+			if (result.done) break;
+			chunks.push(result.value);
+		}
+	} finally {
+		signal.removeEventListener("abort", cancel);
+		reader.releaseLock();
+	}
+	return signal.aborted ? null : Buffer.concat(chunks);
 }
 function isVinextStreamedHtmlResponse(response) {
 	return response.__vinextStreamedHtmlResponse === true;
@@ -370,24 +405,23 @@ function mergeWebResponse(middlewareHeaders, response, statusOverride) {
 */
 function sendCompressed(req, res, body, contentType, statusCode, extraHeaders = {}, compress = true, statusText) {
 	const buf = typeof body === "string" ? Buffer.from(body) : body;
-	const baseType = contentType.split(";")[0].trim();
-	const varyByEncoding = compress && COMPRESSIBLE_TYPES.has(baseType);
-	const encoding = compress ? negotiateEncoding(req) : "identity";
 	const headersWithoutBodyHeaders = omitHeadersCaseInsensitive(extraHeaders, OMIT_BODY_HEADERS);
+	const { varyAcceptEncoding: varyByEncoding, encoding } = resolveResponseCompression(req, compress, {
+		contentType,
+		cacheControl: readHeaderCaseInsensitive(extraHeaders, "cache-control"),
+		contentEncoding: readHeaderCaseInsensitive(extraHeaders, "content-encoding"),
+		contentLength: buf.length
+	});
 	const writeHead = (headers, responseStatus = statusCode, responseStatusText = statusText) => {
 		if (responseStatusText) res.writeHead(responseStatus, responseStatusText, headers);
 		else res.writeHead(responseStatus, headers);
 	};
-	if (encoding !== "identity" && varyByEncoding && buf.length >= 1024) {
+	if (encoding !== "identity") {
 		writeHead(mergeVaryHeader({
 			...headersWithoutBodyHeaders,
 			"Content-Type": contentType,
 			"Content-Encoding": encoding
 		}, "Accept-Encoding"));
-		if (req.method === "HEAD") {
-			res.end();
-			return;
-		}
 		const compressor = createCompressor(encoding);
 		compressor.end(buf);
 		pipeline(compressor, res, () => {});
@@ -405,6 +439,21 @@ function sendCompressed(req, res, body, contentType, statusCode, extraHeaders =
 		res.end(buf);
 	}
 }
+/** The StaticFileCache key for a request pathname, or null when it is never served. */
+function staticCacheLookupPath(pathname) {
+	let lookupPath = pathname;
+	if (pathname.includes("%")) try {
+		lookupPath = decodeURIComponent(pathname);
+	} catch {
+		return null;
+	}
+	if (lookupPath.startsWith("/.vite/") || lookupPath === "/.vite") return null;
+	return lookupPath;
+}
+/** Pathnames the Pages Router serves from routes rather than the client directory. */
+function isPagesFilesystemExcludedPath(pathname, phase) {
+	return pathname === "/" || pathname === "/api" || pathname.startsWith("/api/") || phase === "direct" && pathname.startsWith(`/_next/static/`);
+}
 /**
 * Try to serve a static file from the client build directory.
 *
@@ -415,8 +464,12 @@ function sendCompressed(req, res, body, contentType, statusCode, extraHeaders =
 *
 * 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.
 */
-async function tryServeStatic(req, res, clientDir, pathname, compress, cache, extraHeaders, statusCode) {
+async function tryServeStatic(req, res, clientDir, pathname, compress, cache, extraHeaders, statusCode, representationHeaders) {
 	if (pathname === "/") return false;
 	const responseStatus = statusCode ?? 200;
 	const omitBody = isNoBodyResponseStatus(responseStatus);
@@ -424,41 +477,35 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 	const rawIfRange = req.headers["if-range"];
 	const ifRange = typeof rawIfRange === "string" ? rawIfRange : void 0;
 	if (cache) {
-		let lookupPath;
-		if (pathname.includes("%")) {
-			try {
-				lookupPath = decodeURIComponent(pathname);
-			} catch {
-				return false;
-			}
-			if (lookupPath.startsWith("/.vite/") || lookupPath === "/.vite") return false;
-		} else {
-			if (pathname.startsWith("/.vite/") || pathname === "/.vite") return false;
-			lookupPath = pathname;
-		}
+		const lookupPath = staticCacheLookupPath(pathname);
+		if (lookupPath === null) return false;
 		const entry = cache.lookup(lookupPath);
 		if (!entry) return false;
 		if (req.method !== "GET" && req.method !== "HEAD") {
 			sendStaticMethodNotAllowed(res, extraHeaders);
 			return true;
 		}
-		const rawAe = compress ? req.headers["accept-encoding"] : void 0;
+		const encodingAllowed = compress && !hasNoTransform((extraHeaders && readHeaderCaseInsensitive(extraHeaders, "cache-control")) ?? entry.original.headers["Cache-Control"]);
+		const rawAe = encodingAllowed ? req.headers["accept-encoding"] : void 0;
 		const parsed = typeof rawAe === "string" ? parseAcceptedEncodings(rawAe) : void 0;
 		const availableVariants = [
 			...entry.zst ? ["zstd"] : [],
 			...entry.br ? ["br"] : [],
 			...entry.gz ? ["gzip"] : []
 		];
-		const variesByEncoding = compress && availableVariants.length > 0;
+		const variesByEncoding = encodingAllowed && availableVariants.length > 0;
 		const selected = parsed ? selectContentEncoding(parsed, availableVariants) : "identity";
 		const variant = selected === "zstd" ? entry.zst : selected === "br" ? entry.br : selected === "gzip" ? entry.gz : entry.original;
+		const notModifiedBaseHeaders = encodingAllowed ? entry.notModifiedHeaders : omitVaryToken(entry.notModifiedHeaders, "Accept-Encoding");
+		const originalHeaders = encodingAllowed ? entry.original.headers : omitVaryToken(entry.original.headers, "Accept-Encoding");
+		const variantHeaders = variant === entry.original ? originalHeaders : variant.headers;
 		const validators = extraHeaders ? resolveStaticValidators(entry.etag, entry.mtimeMs, extraHeaders) : void 0;
 		const effectiveEtag = validators ? validators.etag : entry.etag;
 		const effectiveMtimeMs = validators ? validators.mtimeMs : entry.mtimeMs;
 		const preconditionResult = responseStatus === 200 ? evaluateRequestPreconditions(req, effectiveEtag, effectiveMtimeMs) : "proceed";
 		if (preconditionResult === "precondition-failed") {
 			res.writeHead(412, {
-				...entry.notModifiedHeaders,
+				...notModifiedBaseHeaders,
 				...extraHeaders,
 				"Content-Type": entry.original.headers["Content-Type"],
 				"Accept-Ranges": "bytes"
@@ -468,10 +515,10 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 		}
 		if (preconditionResult === "not-modified") {
 			const notModifiedHeaders = variesByEncoding ? mergeVaryHeader({
-				...entry.notModifiedHeaders,
+				...notModifiedBaseHeaders,
 				...extraHeaders
 			}, "Accept-Encoding") : {
-				...entry.notModifiedHeaders,
+				...notModifiedBaseHeaders,
 				...extraHeaders
 			};
 			if (selected !== "identity") notModifiedHeaders["Content-Encoding"] = selected;
@@ -482,7 +529,7 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 		const range = resolveRequestedRange(requestRange, ifRange, entry.original.size, effectiveEtag ?? "", effectiveMtimeMs, responseStatus);
 		if (range.kind === "unsatisfiable") {
 			res.writeHead(416, {
-				...entry.notModifiedHeaders,
+				...notModifiedBaseHeaders,
 				...extraHeaders,
 				"Content-Type": entry.original.headers["Content-Type"],
 				"Accept-Ranges": "bytes",
@@ -494,8 +541,9 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 		if (range.kind === "range") {
 			const length = range.end - range.start + 1;
 			const rangeHeaders = {
-				...entry.original.headers,
+				...originalHeaders,
 				...extraHeaders,
+				...representationHeaders,
 				"Accept-Ranges": "bytes",
 				"Content-Length": String(length),
 				"Content-Range": `bytes ${range.start}-${range.end}/${entry.original.size}`
@@ -510,8 +558,9 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 			return true;
 		}
 		const responseHeaders = {
-			...variant.headers,
+			...variantHeaders,
 			...extraHeaders,
+			...representationHeaders,
 			"Accept-Ranges": "bytes"
 		};
 		res.writeHead(responseStatus, variesByEncoding ? mergeVaryHeader(responseHeaders, "Accept-Encoding") : responseHeaders);
@@ -549,8 +598,6 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 	const isHashed = pathname.includes(`/${ASSET_PREFIX_URL_DIR}/`);
 	const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600";
 	const etag = isHashed && etagFromFilenameHash(resolved.path, ext) || `W/"${resolved.size}-${Math.floor(resolved.mtimeMs / 1e3)}"`;
-	const baseType = ct.split(";")[0].trim();
-	const isCompressible = compress && COMPRESSIBLE_TYPES.has(baseType);
 	const baseHeaders = {
 		"Content-Type": ct,
 		"Cache-Control": cacheControl,
@@ -559,7 +606,12 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 		"Accept-Ranges": "bytes",
 		...extraHeaders
 	};
-	const encoding = isCompressible ? negotiateEncoding(req) : "identity";
+	const { varyAcceptEncoding: isCompressible, encoding } = resolveResponseCompression(req, compress, {
+		contentType: ct,
+		cacheControl: (extraHeaders && readHeaderCaseInsensitive(extraHeaders, "cache-control")) ?? cacheControl,
+		contentEncoding: extraHeaders && readHeaderCaseInsensitive(extraHeaders, "content-encoding"),
+		contentLength: resolved.size
+	});
 	const validators = extraHeaders ? resolveStaticValidators(etag, resolved.mtimeMs, extraHeaders) : void 0;
 	const effectiveEtag = validators ? validators.etag : etag;
 	const effectiveMtimeMs = validators ? validators.mtimeMs : resolved.mtimeMs;
@@ -595,6 +647,7 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 		const length = range.end - range.start + 1;
 		const rangeHeaders = {
 			...baseHeaders,
+			...representationHeaders,
 			"Content-Length": String(length),
 			"Content-Range": `bytes ${range.start}-${range.end}/${resolved.size}`
 		};
@@ -609,6 +662,7 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 	if (isCompressible && encoding !== "identity") {
 		res.writeHead(responseStatus, mergeVaryHeader({
 			...baseHeaders,
+			...representationHeaders,
 			"Content-Encoding": encoding
 		}, "Accept-Encoding"));
 		if (omitBody || req.method === "HEAD") {
@@ -626,6 +680,7 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 	}
 	const identityHeaders = {
 		...baseHeaders,
+		...representationHeaders,
 		"Content-Length": String(resolved.size)
 	};
 	res.writeHead(responseStatus, isCompressible ? mergeVaryHeader(identityHeaders, "Accept-Encoding") : identityHeaders);
@@ -734,7 +789,7 @@ async function statIfFile(filePath) {
 * When `urlOverride` is provided, it is used as the path + query string
 * instead of `req.url`.
 */
-function nodeToWebRequest(req, urlOverride, prerenderSecret, i18nConfig, authorizeOnDemandRevalidate) {
+function nodeToWebRequest(req, urlOverride, prerenderSecret, i18nConfig, authorizeOnDemandRevalidate, signal) {
 	const proto = resolveRequestProtocol(req);
 	const rawHeaders = nodeHeadersToWebHeaders(req.headers);
 	const revalidationHostname = readTrustedRevalidationHostname(rawHeaders, i18nConfig, authorizeOnDemandRevalidate);
@@ -751,9 +806,10 @@ function nodeToWebRequest(req, urlOverride, prerenderSecret, i18nConfig, authori
 	const hasBody = method !== "GET" && method !== "HEAD";
 	const init = {
 		method,
-		headers
+		headers,
+		signal
 	};
-	if (hasBody) {
+	if (hasBody && !signal?.aborted) {
 		init.body = readNodeStream(req);
 		init.duplex = "half";
 	}
@@ -776,22 +832,23 @@ async function sendWebResponse(webResponse, req, res, compress) {
 		if (existing !== void 0) nodeHeaders[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
 		else nodeHeaders[key] = value;
 	});
-	const alreadyEncoded = webResponse.headers.get("content-encoding") !== null;
-	if (!webResponse.body) {
-		writeHead(nodeHeaders);
-		res.end();
-		return;
-	}
-	const baseType = (webResponse.headers.get("content-type") ?? "").split(";")[0].trim();
-	const varyByEncoding = compress && !alreadyEncoded && COMPRESSIBLE_TYPES.has(baseType);
-	const encoding = compress && !alreadyEncoded ? negotiateEncoding(req) : "identity";
-	const shouldCompress = encoding !== "identity" && COMPRESSIBLE_TYPES.has(baseType);
+	const { varyAcceptEncoding: varyByEncoding, encoding } = resolveResponseCompression(req, compress, {
+		contentType: webResponse.headers.get("content-type"),
+		cacheControl: webResponse.headers.get("cache-control"),
+		contentEncoding: webResponse.headers.get("content-encoding"),
+		contentLength: webResponse.body ? parseContentLengthHeader(webResponse.headers.get("content-length")) : 0
+	});
+	const shouldCompress = encoding !== "identity";
 	if (shouldCompress) {
 		delete nodeHeaders["content-length"];
-		delete nodeHeaders["Content-Length"];
+		delete nodeHeaders["content-encoding"];
 		nodeHeaders["Content-Encoding"] = encoding;
 	}
 	writeHead(varyByEncoding ? mergeVaryHeader(nodeHeaders, "Accept-Encoding") : nodeHeaders);
+	if (!webResponse.body) {
+		res.end();
+		return;
+	}
 	if (req.method === "HEAD") {
 		cancelResponseBody(webResponse);
 		res.end();
@@ -832,7 +889,7 @@ function waitForNodeResponseCompletion(res) {
 * Pages Router (dist/server/entry.js) and configures the appropriate handler.
 */
 async function startProdServer(options = {}) {
-	installSocketErrorBackstop();
+	installSocketErrorBackstop({ runningServer: options.purpose !== "prerender" });
 	const { port = process.env.PORT ? parseInt(process.env.PORT) : 3e3, host = "0.0.0.0", outDir = path.resolve("dist"), rscEntryPath: explicitRscEntryPath, serverDir: explicitServerDir, serverEntryPath: explicitServerEntryPath, noCompression = false, purpose, silent = false } = options;
 	if (purpose === "prerender") registerPrerenderCloudflareLoader();
 	const compress = !noCompression;
@@ -861,6 +918,7 @@ async function startProdServer(options = {}) {
 		port,
 		host,
 		clientDir,
+		serverDir,
 		serverEntryPath,
 		compress,
 		purpose,
@@ -877,6 +935,23 @@ function createNodeExecutionContext(trustedRevalidateOrigin) {
 		trustedRevalidateOrigin
 	};
 }
+/**
+* Sets the prerender special-error marker only from the page's recorded
+* special error, which middleware, route handlers and external rewrites can't
+* reach, and drops one they set.
+*/
+function markPrerenderSpecialError(response, marker) {
+	const trusted = marker !== void 0 && marker.status === response.status;
+	if (!trusted && !response.headers.has("x-vinext-prerender-special-error")) return response;
+	const headers = new Headers(response.headers);
+	headers.delete(VINEXT_PRERENDER_SPECIAL_ERROR_HEADER);
+	if (trusted) headers.set(VINEXT_PRERENDER_SPECIAL_ERROR_HEADER, JSON.stringify(marker.headers));
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
 function resolveTrustedNodeRevalidateOrigin(req, configuredHost, configuredPort) {
 	const port = req.socket.localPort ?? configuredPort;
 	return `http://${normalizeInternalFetchHost(configuredHost)}:${port}`;
@@ -1008,8 +1083,9 @@ function installPagesClientAssets(options) {
 * 4. Stream the Web Response back (with optional compression)
 */
 async function startAppRouterServer(options) {
-	const { port, host, clientDir, serverDir, rscEntryPath, compress, purpose, silent } = options;
+	const { port, host, clientDir, serverDir, rscEntryPath, compress: compressOption, purpose, silent } = options;
 	const prerenderSecret = readPrerenderSecret(serverDir);
+	const compress = compressOption && readServerCompress(serverDir);
 	const rscModule = await importServerEntryModule(rscEntryPath);
 	const rscEntryRequire = createServerEntryRequire(rscEntryPath);
 	const rscHandler = resolveAppRouterHandler(rscModule.default);
@@ -1045,9 +1121,63 @@ async function startAppRouterServer(options) {
 	const seededRoutes = await runWithServerEntryRequire(rscEntryRequire, () => seedPrerenderedRoutes(serverDir));
 	if (seededRoutes > 0) console.log(`[vinext] Seeded ${seededRoutes} pre-rendered route${seededRoutes !== 1 ? "s" : ""} into memory cache`);
 	const staticCache = await StaticFileCache.create(clientDir);
+	const serveImageOptimization = async (req, res, request, signal) => {
+		const stagedHeaders = omitHeadersCaseInsensitive(mergeResponseHeaders({}, new Response(null, { headers: signal.middlewareHeaders })), OMIT_STATIC_RESPONSE_HEADERS);
+		for (const [name, value] of Object.entries(stagedHeaders)) res.setHeader(name, value);
+		const parsedUrl = new URL(`/${signal.search}`, "http://localhost");
+		const params = parseImageParams(parsedUrl, appImageAllowedWidths, imageConfig?.qualities);
+		if (!params) {
+			res.writeHead(400);
+			res.end("Bad Request");
+			return;
+		}
+		const sendUnsafeContentType = () => {
+			res.writeHead(400);
+			res.end("The requested resource is not an allowed image type");
+		};
+		const isSafeSourcePath = (sourcePath) => isSafeImageContentType(contentTypeForPath(sourcePath), imageConfig?.dangerouslyAllowSVG);
+		const imageSecurityHeaders = {
+			"Content-Security-Policy": imageConfig?.contentSecurityPolicy ?? "script-src 'none'; frame-src 'none'; sandbox;",
+			"X-Content-Type-Options": "nosniff",
+			"Content-Disposition": imageConfig?.contentDispositionType === "attachment" ? "attachment" : "inline"
+		};
+		const serveSource = (sourcePath) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, imageSecurityHeaders, void 0, IMAGE_REPRESENTATION_HEADERS);
+		const sourceUrl = new URL(params.imageUrl, request.url);
+		let sourcePathname = null;
+		try {
+			sourcePathname = normalizePath(normalizePathnameForRouteMatchStrict(sourceUrl.pathname));
+		} catch {}
+		if (!isSafeSourcePath(sourcePathname ?? params.imageUrl)) {
+			sendUnsafeContentType();
+			return;
+		}
+		const assetLookupPath = sourcePathname !== null ? resolveAppRouterAssetPath(sourcePathname, appAssetPathPrefix, appRouterAssetPrefix) : null;
+		if (assetLookupPath && await serveSource(assetLookupPath)) return;
+		if (sourcePathname !== null) {
+			const sourceResponse = await rscHandler(new Request(sourceUrl, { signal: request.signal }), createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port)));
+			const sourceSignal = isImageSourceBodyStatus(sourceResponse.status) ? readStaticFileSignal(sourceResponse) : null;
+			cancelResponseBody(sourceResponse, request.signal.reason);
+			if (request.signal.aborted) return;
+			if (sourceSignal !== null) {
+				let sourcePath = sourceSignal;
+				try {
+					sourcePath = decodeURIComponent(sourceSignal);
+				} catch {}
+				if (!isSafeSourcePath(sourcePath)) {
+					sendUnsafeContentType();
+					return;
+				}
+				if (await serveSource(sourcePath)) return;
+			}
+		}
+		res.writeHead(400);
+		res.end(INVALID_IMAGE_SOURCE_MESSAGE);
+	};
+	const clientBuildFiles = new Set(Array.isArray(rscModule.__clientBuildFiles) ? rscModule.__clientBuildFiles : []);
 	const handleRequestImpl = async (req, res) => {
 		const rawUrl = req.url ?? "/";
 		const rawPathname = rawUrl.split("?")[0];
+		if (sendRepeatedSlashRedirect(rawUrl, res)) return;
 		if (isOpenRedirectShaped(rawPathname)) {
 			res.writeHead(404);
 			res.end("This page could not be found");
@@ -1076,33 +1206,28 @@ async function startAppRouterServer(options) {
 				if (await tryServeStatic(req, res, clientDir, assetLookupPath, compress, staticCache)) return;
 			}
 		}
-		if (isImageOptimizationPath(pathname)) {
-			const parsedUrl = new URL(rawUrl, "http://localhost");
-			const params = parseImageParams(parsedUrl, appImageAllowedWidths, imageConfig?.qualities);
-			if (!params) {
-				res.writeHead(400);
-				res.end("Bad Request");
+		if (req.method === "GET" || req.method === "HEAD") {
+			const clientBuildFile = resolveClientBuildFile(normalizedRawPathname, appRouterBasePath, clientBuildFiles);
+			if (clientBuildFile && await tryServeStatic(req, res, clientDir, clientBuildFile, compress, staticCache)) return;
+		}
+		try {
+			const request = nodeToWebRequest(req, rawUrl, prerenderSecret, appRouterI18nConfig, appRouterAuthorizeOnDemandRevalidate, signalFromNodeResponse(res));
+			const ctx = createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port));
+			const recorded = {};
+			if (purpose === "prerender") ctx.recordPrerenderSpecialError = (marker) => {
+				recorded.marker = marker;
+			};
+			const response = await rscHandler(request, ctx);
+			if (request.signal.aborted) {
+				cancelResponseBody(response, request.signal.reason);
 				return;
 			}
-			const ct = contentTypeForPath(params.imageUrl);
-			if (!isSafeImageContentType(ct, imageConfig?.dangerouslyAllowSVG)) {
-				res.writeHead(400);
-				res.end("The requested resource is not an allowed image type");
+			const imageSignal = readImageOptimizationSignal(response);
+			if (imageSignal) {
+				cancelResponseBody(response);
+				await serveImageOptimization(req, res, request, imageSignal);
 				return;
 			}
-			const imageSecurityHeaders = {
-				"Content-Security-Policy": imageConfig?.contentSecurityPolicy ?? "script-src 'none'; frame-src 'none'; sandbox;",
-				"X-Content-Type-Options": "nosniff",
-				"Content-Disposition": imageConfig?.contentDispositionType === "attachment" ? "attachment" : "inline"
-			};
-			if (await tryServeStatic(req, res, clientDir, params.imageUrl, false, staticCache, imageSecurityHeaders)) return;
-			res.writeHead(404);
-			res.end("Image not found");
-			return;
-		}
-		try {
-			const request = nodeToWebRequest(req, rawUrl, prerenderSecret, appRouterI18nConfig, appRouterAuthorizeOnDemandRevalidate);
-			const response = await rscHandler(request, createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port)));
 			const staticFileSignal = readStaticFileSignal(response);
 			if (staticFileSignal) {
 				let staticFilePath = "/";
@@ -1118,7 +1243,7 @@ async function startAppRouterServer(options) {
 				await sendWebResponse(notFoundResponse({ headers: toWebHeaders(staticResponseHeaders) }), req, res, compress);
 				return;
 			}
-			await sendWebResponse(response, req, res, compress);
+			await sendWebResponse(purpose === "prerender" ? markPrerenderSpecialError(response, recorded.marker) : response, req, res, compress);
 		} catch (e) {
 			console.error("[vinext] Server error:", e);
 			if (!res.headersSent) {
@@ -1149,7 +1274,7 @@ async function startAppRouterServer(options) {
 			},
 			getStatus: () => res.statusCode,
 			headers,
-			isRsc: new URL(target, "http://localhost").pathname.endsWith(".rsc") || headers.get("RSC") === "1",
+			isRsc: target.split("?", 1)[0].endsWith(".rsc") || headers.get("RSC") === "1",
 			method: req.method ?? "GET",
 			target
 		});
@@ -1195,7 +1320,45 @@ function readPagesServerEntryPageRoutes(value) {
 * - vinextConfig — embedded next.config.js settings
 */
 async function startPagesRouterServer(options) {
-	const { port, host, clientDir, serverEntryPath, compress, purpose, silent } = options;
+	const { port, host, purpose, silent } = options;
+	const handler = await createPagesRouterRequestHandler(options);
+	const server = createServer(handler);
+	await new Promise((resolve) => {
+		server.listen(port, host, () => {
+			const addr = server.address();
+			const actualPort = typeof addr === "object" && addr ? addr.port : port;
+			if (!silent) logProdServerStarted(host, actualPort, purpose);
+			resolve();
+		});
+	});
+	const addr = server.address();
+	return {
+		server,
+		port: typeof addr === "object" && addr ? addr.port : port
+	};
+}
+/**
+* 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.
+*/
+async function createPagesPreviewHandler(options) {
+	const clientDir = path.resolve(options.clientDir);
+	const serverDir = path.resolve(options.serverDir);
+	const serverEntryPath = path.join(serverDir, "entry.js");
+	if (!fs.existsSync(serverEntryPath)) return null;
+	return createPagesRouterRequestHandler({
+		port: options.port,
+		host: options.host,
+		clientDir,
+		serverDir,
+		serverEntryPath,
+		compress: false
+	});
+}
+async function createPagesRouterRequestHandler(options) {
+	const { port, host, clientDir, serverDir, serverEntryPath, compress: compressOption, purpose } = options;
 	const serverEntry = await importServerEntryModule(serverEntryPath);
 	const serverEntryRequire = createServerEntryRequire(serverEntryPath);
 	const { renderPage, handleApiRoute: handleApi, authorizeOnDemandRevalidate, runMiddleware, vinextConfig, buildId: pagesBuildId } = serverEntry;
@@ -1205,11 +1368,13 @@ async function startPagesRouterServer(options) {
 	const hasMiddleware = serverEntry.hasMiddleware === true;
 	const pageRoutes = readPagesServerEntryPageRoutes(serverEntry.pageRoutes);
 	const prerenderSecret = readPrerenderSecret(path.dirname(serverEntryPath));
+	const compress = compressOption && readServerCompress(serverDir);
 	const basePath = vinextConfig?.basePath ?? "";
 	const assetPrefix = vinextConfig?.assetPrefix ?? "";
 	const pagesAssetPathPrefix = assetPrefixPathname(assetPrefix);
 	const assetBase = basePath ? `${basePath}/` : "/";
 	const trailingSlash = vinextConfig?.trailingSlash ?? false;
+	const skipTrailingSlashRedirect = vinextConfig?.skipTrailingSlashRedirect ?? false;
 	const skipProxyUrlNormalize = vinextConfig?.skipProxyUrlNormalize ?? false;
 	const i18nConfig = vinextConfig?.i18n ?? null;
 	const configRedirects = vinextConfig?.redirects ?? [];
@@ -1261,6 +1426,7 @@ async function startPagesRouterServer(options) {
 	const handleRequestImpl = async (req, res) => {
 		const rawUrl = req.url ?? "/";
 		const rawPagesPathnameBeforeNormalize = rawUrl.split("?")[0];
+		if (sendRepeatedSlashRedirect(rawUrl, res)) return;
 		if (isOpenRedirectShaped(rawPagesPathnameBeforeNormalize)) {
 			res.writeHead(404);
 			res.end("This page could not be found");
@@ -1366,18 +1532,55 @@ async function startPagesRouterServer(options) {
 			const reqHeaders = filterInternalHeaders(rawReqHeaders);
 			if (revalidationHostname) reqHeaders.set("host", revalidationHostname);
 			const method = req.method ?? "GET";
-			const hasBody = method !== "GET" && method !== "HEAD";
-			const webRequest = new Request(`${protocol}://${revalidationHostname ?? hostHeader}${url}`, {
+			const signal = signalFromNodeResponse(res);
+			const hasBody = method !== "GET" && method !== "HEAD" && !signal.aborted;
+			const requestOrigin = `${protocol}://${revalidationHostname ?? hostHeader}`;
+			const webRequest = new Request(new URL(url, requestOrigin), {
 				method,
 				headers: reqHeaders,
+				signal,
 				body: hasBody ? readNodeStream(req) : void 0,
 				duplex: hasBody ? "half" : void 0
 			});
 			const middlewareRequest = isDataReq && skipProxyUrlNormalize ? new Request(new URL(originalRenderUrl, webRequest.url), webRequest) : void 0;
+			const resolvePublicImageSource = async (sourceUrl) => {
+				const rawSourcePathname = sourceUrl.pathname;
+				if (getRepeatedSlashRedirect(rawSourcePathname) || isOpenRedirectShaped(rawSourcePathname)) return null;
+				const sourceRequestPathname = normalizePath(rawSourcePathname);
+				const sourceHadBasePath = !basePath || hasBasePath(sourceRequestPathname, basePath);
+				const strippedSourcePathname = stripBasePath(sourceRequestPathname, basePath);
+				if (isNextDataPathname(strippedSourcePathname)) return null;
+				let sourcePath = null;
+				const result = await runPagesRequest(new Request(new URL(strippedSourcePathname + sourceUrl.search, sourceUrl), { signal: webRequest.signal }), {
+					...deps,
+					hadBasePath: sourceHadBasePath,
+					isDataReq: false,
+					isDataRequest: false,
+					middlewareRequest: void 0,
+					dataNotFoundResponse: null,
+					recordCacheability: false,
+					rawSearch: sourceUrl.search,
+					configMatchPathname: strippedSourcePathname,
+					runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, sourceHadBasePath) : null,
+					renderPage: null,
+					handleApi: null,
+					serveFilesystemRoute: async (candidate, _stagedHeaders, phase) => {
+						if (isImageOptimizationPath(candidate) || isPagesFilesystemExcludedPath(candidate, phase)) return false;
+						const lookupPath = staticCacheLookupPath(candidate);
+						if (lookupPath === null || lookupPath === "/" || !staticCache.lookup(lookupPath)) return false;
+						sourcePath = candidate;
+						return new Response(null);
+					}
+				});
+				if (result.type !== "response") return null;
+				cancelResponseBody(result.response);
+				return isImageSourceBodyStatus(result.response.status) ? sourcePath : null;
+			};
 			const deps = {
 				assetPrefix,
 				basePath,
 				trailingSlash,
+				skipTrailingSlashRedirect,
 				i18nConfig,
 				configRedirects,
 				configRewrites,
@@ -1400,8 +1603,8 @@ async function startPagesRouterServer(options) {
 					originalUrl: originalRenderUrl
 				}, stagedHeaders?.has("Cache-Control") ? new Headers({ "Cache-Control": stagedHeaders.get("Cache-Control") }) : void 0) : null,
 				handleApi: typeof handleApi === "function" ? (request, apiUrl) => handleApi(request, apiUrl, createNodeExecutionContext(), resolveTrustedNodeRevalidateOrigin(req, host, port), "node") : null,
-				serveFilesystemRoute: async (requestPathname, stagedHeaders, phase, resolvedUrl) => {
-					if (isImageOptimizationPath(requestPathname)) {
+				serveFilesystemRoute: async (requestPathname, stagedHeaders, phase, resolvedUrl, _request, resolvedPathnameHasBasePath) => {
+					if (resolvedPathnameHasBasePath && isImageOptimizationPath(requestPathname)) {
 						for (const [name, value] of Object.entries(stagedHeaders)) res.setHeader(name, value);
 						const parsedUrl = new URL(resolvedUrl, "http://localhost");
 						const params = parseImageParams(parsedUrl, allowedImageWidths, pagesImageConfig?.qualities);
@@ -1410,23 +1613,42 @@ async function startPagesRouterServer(options) {
 							res.end("Bad Request");
 							return true;
 						}
-						const ct = contentTypeForPath(params.imageUrl);
-						if (!isSafeImageContentType(ct, pagesImageConfig?.dangerouslyAllowSVG)) {
+						const sendUnsafeContentType = () => {
 							res.writeHead(400);
 							res.end("The requested resource is not an allowed image type");
-							return true;
-						}
+						};
+						const isSafeSourcePath = (sourcePath) => isSafeImageContentType(contentTypeForPath(sourcePath), pagesImageConfig?.dangerouslyAllowSVG);
 						const imageSecurityHeaders = {
 							"Content-Security-Policy": pagesImageConfig?.contentSecurityPolicy ?? "script-src 'none'; frame-src 'none'; sandbox;",
 							"X-Content-Type-Options": "nosniff",
 							"Content-Disposition": pagesImageConfig?.contentDispositionType === "attachment" ? "attachment" : "inline"
 						};
-						if (await tryServeStatic(req, res, clientDir, params.imageUrl, false, staticCache, imageSecurityHeaders)) return true;
-						res.writeHead(404);
-						res.end("Image not found");
+						const serveSource = (sourcePath) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, imageSecurityHeaders, void 0, IMAGE_REPRESENTATION_HEADERS);
+						const sourceUrl = new URL(params.imageUrl, webRequest.url);
+						let sourcePathname = null;
+						try {
+							sourcePathname = normalizePath(normalizePathnameForRouteMatchStrict(sourceUrl.pathname));
+						} catch {}
+						if (!isSafeSourcePath(sourcePathname ?? params.imageUrl)) {
+							sendUnsafeContentType();
+							return true;
+						}
+						const assetLookupPath = sourcePathname !== null ? resolveAppRouterAssetPath(sourcePathname, pagesAssetPathPrefix, assetPrefix) : null;
+						if (assetLookupPath && await serveSource(assetLookupPath)) return true;
+						const sourcePath = sourcePathname !== null ? await resolvePublicImageSource(sourceUrl) : null;
+						if (webRequest.signal.aborted) return true;
+						if (sourcePath !== null) {
+							if (!isSafeSourcePath(staticCacheLookupPath(sourcePath) ?? sourcePath)) {
+								sendUnsafeContentType();
+								return true;
+							}
+							if (await serveSource(sourcePath)) return true;
+						}
+						res.writeHead(400);
+						res.end(INVALID_IMAGE_SOURCE_MESSAGE);
 						return true;
 					}
-					if (requestPathname === "/" || requestPathname === "/api" || requestPathname.startsWith("/api/") || phase === "direct" && requestPathname.startsWith(`/_next/static/`)) return false;
+					if (isPagesFilesystemExcludedPath(requestPathname, phase)) return false;
 					return tryServeStatic(req, res, clientDir, requestPathname, compress, staticCache, stagedHeaders);
 				}
 			};
@@ -1434,13 +1656,18 @@ async function startPagesRouterServer(options) {
 			if (result.type === "handled") return;
 			if (result.type === "response") {
 				const { response } = result;
+				if (webRequest.signal.aborted) {
+					cancelResponseBody(response, webRequest.signal.reason);
+					return;
+				}
 				const streamedApi = isVinextStreamedApiResponse(response);
 				if (isVinextStreamedHtmlResponse(response) || streamedApi || !response.body || result.defaultContentType === void 0) {
 					if (streamedApi && result.defaultContentType !== void 0 && !response.headers.has("content-type")) response.headers.set("content-type", result.defaultContentType);
 					await sendWebResponse(response, req, res, compress);
 					return;
 				}
-				const responseBody = Buffer.from(await response.arrayBuffer());
+				const responseBody = await bufferResponseBodyUntilAborted(response, webRequest.signal);
+				if (!responseBody) return;
 				const ct = response.headers.get("content-type") ?? result.defaultContentType;
 				const responseHeaders = {};
 				response.headers.forEach((v, k) => {
@@ -1464,22 +1691,9 @@ async function startPagesRouterServer(options) {
 			}
 		}
 	};
-	const server = createServer((req, res) => {
+	return (req, res) => {
 		runWithServerEntryRequire(serverEntryRequire, () => handleRequest(req, res));
-	});
-	await new Promise((resolve) => {
-		server.listen(port, host, () => {
-			const addr = server.address();
-			const actualPort = typeof addr === "object" && addr ? addr.port : port;
-			if (!silent) logProdServerStarted(host, actualPort, purpose);
-			resolve();
-		});
-	});
-	const addr = server.address();
-	return {
-		server,
-		port: typeof addr === "object" && addr ? addr.port : port
 	};
 }
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, importServerEntryModule, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, readNodeStream, rememberCurrentServerEntryImportMtime, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, resolveServerEntryImportUrl, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic, waitForNodeResponseCompletion };
+export { COMPRESS_THRESHOLD, createPagesPreviewHandler, importServerEntryModule, isCompressibleContentType, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, readNodeStream, rememberCurrentServerEntryImportMtime, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, resolveServerEntryImportUrl, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic, waitForNodeResponseCompletion };