vinext 1.1.0 → 1.2.0

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

@@ -155,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 { COMPRESS_THRESHOLD, isCompressibleContentType, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, trustProxy, trustedHosts, tryServeStatic, waitForNodeResponseCompletion };

package/dist/server/prod-server.js

@@ -8,17 +8,17 @@ import { hasBasePath, stripBasePath } from "../utils/base-path.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, sendRepeatedSlashRedirect } 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 { signalFromNodeResponse } from "./node-response-signal.js";
-import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_RESPONSE_CACHE_STATE, isImageOptimizationPath, isSafeImageContentType, parseImageParams } from "./image-optimization.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";
@@ -28,6 +28,7 @@ import { runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pip
 import { computeClientRuntimeMetadata } from "../utils/client-runtime-metadata.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";
@@ -335,10 +336,15 @@ 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
@@ -433,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.
 *
@@ -456,18 +477,8 @@ 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") {
@@ -878,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;
@@ -1110,6 +1121,59 @@ 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];
@@ -1142,29 +1206,9 @@ 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");
-				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");
-				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, void 0, IMAGE_REPRESENTATION_HEADERS)) return;
-			res.writeHead(404);
-			res.end("Image not found");
-			return;
+		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));
@@ -1175,7 +1219,13 @@ async function startAppRouterServer(options) {
 			};
 			const response = await rscHandler(request, ctx);
 			if (request.signal.aborted) {
+				cancelResponseBody(response, request.signal.reason);
+				return;
+			}
+			const imageSignal = readImageOptimizationSignal(response);
+			if (imageSignal) {
 				cancelResponseBody(response);
+				await serveImageOptimization(req, res, request, imageSignal);
 				return;
 			}
 			const staticFileSignal = readStaticFileSignal(response);
@@ -1270,7 +1320,45 @@ function readPagesServerEntryPageRoutes(value) {
 * - vinextConfig — embedded next.config.js settings
 */
 async function startPagesRouterServer(options) {
-	const { port, host, clientDir, serverDir, serverEntryPath, compress: compressOption, 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;
@@ -1286,6 +1374,7 @@ async function startPagesRouterServer(options) {
 	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 ?? [];
@@ -1445,7 +1534,8 @@ async function startPagesRouterServer(options) {
 			const method = req.method ?? "GET";
 			const signal = signalFromNodeResponse(res);
 			const hasBody = method !== "GET" && method !== "HEAD" && !signal.aborted;
-			const webRequest = new Request(`${protocol}://${revalidationHostname ?? hostHeader}${url}`, {
+			const requestOrigin = `${protocol}://${revalidationHostname ?? hostHeader}`;
+			const webRequest = new Request(new URL(url, requestOrigin), {
 				method,
 				headers: reqHeaders,
 				signal,
@@ -1453,10 +1543,44 @@ async function startPagesRouterServer(options) {
 				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,
@@ -1479,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);
@@ -1489,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, void 0, IMAGE_REPRESENTATION_HEADERS)) 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);
 				}
 			};
@@ -1514,7 +1657,7 @@ async function startPagesRouterServer(options) {
 			if (result.type === "response") {
 				const { response } = result;
 				if (webRequest.signal.aborted) {
-					cancelResponseBody(response);
+					cancelResponseBody(response, webRequest.signal.reason);
 					return;
 				}
 				const streamedApi = isVinextStreamedApiResponse(response);
@@ -1548,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 { COMPRESS_THRESHOLD, importServerEntryModule, isCompressibleContentType, 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 };

package/dist/server/proper-error.d.ts

@@ -0,0 +1,4 @@
+//#region src/server/proper-error.d.ts
+/** Turn a thrown value into an Error, as Next.js does before reporting it. */
+export declare function getProperError(error: unknown): Error;
+//#endregion

package/dist/server/proper-error.js

@@ -0,0 +1,31 @@
+//#region src/server/proper-error.ts
+function isPlainObject(value) {
+	if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || Object.prototype.hasOwnProperty.call(prototype, "isPrototypeOf");
+}
+/** JSON.stringify that replaces circular references with "[Circular]". */
+function safeStringifyLite(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return JSON.stringify(value, (_key, nested) => {
+		if (typeof nested === "object" && nested !== null) {
+			if (seen.has(nested)) return "[Circular]";
+			seen.add(nested);
+		}
+		return nested;
+	});
+}
+function isError(value) {
+	return typeof value === "object" && value !== null && "name" in value && "message" in value;
+}
+/** Turn a thrown value into an Error, as Next.js does before reporting it. */
+function getProperError(error) {
+	if (isError(error)) return error;
+	if (process.env.NODE_ENV === "development") {
+		if (typeof error === "undefined") return /* @__PURE__ */ new Error("An undefined error was thrown, see here for more info: https://nextjs.org/docs/messages/threw-undefined");
+		if (error === null) return /* @__PURE__ */ new Error("A null error was thrown, see here for more info: https://nextjs.org/docs/messages/threw-undefined");
+	}
+	return new Error(isPlainObject(error) ? safeStringifyLite(error) : String(error));
+}
+//#endregion
+export { getProperError };

package/dist/server/request-pipeline.d.ts

@@ -69,7 +69,10 @@ export declare function guardProtocolRelativeUrl(rawPathname: string, search?: s
 export type HeaderRecord = Record<string, string | string[]>;
 type ResolvePublicFileRouteOptions = {
   cleanPathname: string;
-  middlewareContext: StaticFileSignalContext;
+  /** `requestHeaders` holds middleware's request-header override instructions. */
+  middlewareContext: StaticFileSignalContext & {
+    requestHeaders?: Headers | null;
+  };
   pathname: string;
   publicFiles: ReadonlySet<string>;
   request: Request;

package/dist/server/request-pipeline.js

@@ -1,5 +1,5 @@
 import "../utils/protocol-headers.js";
-import { getUnconsumedMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
+import { buildRequestHeadersFromMiddlewareResponse, getUnconsumedMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
 import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS } from "./headers.js";
 import { forbiddenResponse, methodNotAllowedResponse, notFoundResponse } from "./http-error-responses.js";
@@ -100,7 +100,8 @@ function resolvePublicFileRoute(options) {
 	if (options.pathname.endsWith(".rsc")) return null;
 	if (!options.publicFiles.has(options.cleanPathname)) return null;
 	if (options.request.method !== "GET" && options.request.method !== "HEAD") return methodNotAllowedResponse("GET, HEAD", { headers: options.middlewareContext.headers ?? void 0 });
-	return createStaticFileSignal(options.cleanPathname, options.middlewareContext);
+	const { requestHeaders } = options.middlewareContext;
+	return createStaticFileSignal(options.cleanPathname, options.middlewareContext, requestHeaders ? buildRequestHeadersFromMiddlewareResponse(options.request.headers, requestHeaders) : null);
 }
 function normalizeTrailingSlashPathname(pathname, trailingSlash) {
 	if (pathname === "/" || pathname === "/api" || pathname.startsWith("/api/")) return null;

package/dist/server/revalidation-request.d.ts

@@ -1,6 +1,7 @@
 import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
 //#region src/server/revalidation-request.d.ts
 export declare function getRevalidateSecret(): string;
+export declare function safeEqual(first: string, second: string): boolean;
 export declare function isRevalidateSecret(value: string | null | undefined): boolean;
 /** Match Next.js: the header value must equal the preview/revalidation secret. */
 export declare function isOnDemandRevalidateRequest(headerValue: string | string[] | null | undefined): boolean;

package/dist/server/revalidation-request.js

@@ -34,4 +34,4 @@ function isOnDemandRevalidateRequest(headerValue) {
 	return typeof headerValue === "string" && isRevalidateSecret(headerValue);
 }
 //#endregion
-export { PRERENDER_REVALIDATE_HEADER, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret };
+export { PRERENDER_REVALIDATE_HEADER, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, safeEqual };