vinext 0.0.51 → 0.0.53

package/dist/server/prod-server.js

@@ -1,21 +1,26 @@
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
-import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
-import { VINEXT_PRERENDER_SECRET_HEADER, VINEXT_STATIC_FILE_HEADER } from "./headers.js";
+import { hasBasePath, stripBasePath } from "../utils/base-path.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_STATIC_FILE_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { applyMiddlewareRequestHeaders, isExternalUrl, matchRedirect, matchRewrite, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { applyConfigHeadersToHeaderRecord, filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
+import { applyConfigHeadersToHeaderRecord, filterInternalHeaders, isOpenRedirectShaped, normalizeTrailingSlash } from "./request-pipeline.js";
+import { mergeRewriteQuery } from "../utils/query.js";
+import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.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 { installSocketErrorBackstop } from "./socket-error-backstop.js";
+import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from "../utils/asset-prefix.js";
 import { CONTENT_TYPES, StaticFileCache, etagFromFilenameHash } from "./static-file-cache.js";
+import { buildNextDataNotFoundResponse, isNextDataPathname, parseNextDataPathname } from "./pages-data-route.js";
 import { manifestFileWithBase } from "../utils/manifest-paths.js";
-import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from "../utils/asset-prefix.js";
-import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isSafeImageContentType, parseImageParams } from "./image-optimization.js";
+import { readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { computeLazyChunks } from "../utils/lazy-chunks.js";
 import { readPrerenderSecret } from "../build/server-manifest.js";
 import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
 import fs from "node:fs";
 import path from "node:path";
-import fsp from "node:fs/promises";
+import fs$1 from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import zlib from "node:zlib";
 import { createServer } from "node:http";
@@ -129,8 +134,20 @@ function mergeResponseHeaders(middlewareHeaders, response) {
 }
 function toWebHeaders(headersRecord) {
 	const headers = new Headers();
-	for (const [key, value] of Object.entries(headersRecord)) if (Array.isArray(value)) for (const item of value) headers.append(key, item);
-	else headers.set(key, value);
+	for (const [key, value] of Object.entries(headersRecord)) appendWebHeader(headers, key, value);
+	return headers;
+}
+function appendWebHeader(headers, key, value) {
+	if (value === void 0) return;
+	if (Array.isArray(value)) {
+		for (const item of value) headers.append(key, item);
+		return;
+	}
+	headers.set(key, value);
+}
+function nodeHeadersToWebHeaders(headersRecord) {
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(headersRecord)) appendWebHeader(headers, key, value);
 	return headers;
 }
 const NO_BODY_RESPONSE_STATUSES = new Set([
@@ -325,7 +342,7 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 	if (!resolved) return false;
 	const ext = path.extname(resolved.path);
 	const ct = CONTENT_TYPES[ext] ?? "application/octet-stream";
-	const isHashed = pathname.startsWith("/assets/") || pathname.includes("/_next/static/");
+	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();
@@ -415,7 +432,7 @@ async function resolveStaticFile(staticFile) {
 }
 async function statIfFile(filePath) {
 	try {
-		const stat = await fsp.stat(filePath);
+		const stat = await fs$1.stat(filePath);
 		return stat.isFile() ? {
 			size: stat.size,
 			mtimeMs: stat.mtimeMs
@@ -425,35 +442,6 @@ async function statIfFile(filePath) {
 	}
 }
 /**
-* Resolve the host for a request, ignoring X-Forwarded-Host to prevent
-* host header poisoning attacks (open redirects, cache poisoning).
-*
-* X-Forwarded-Host is only trusted when the VINEXT_TRUSTED_HOSTS env var
-* lists the forwarded host value. Without this, an attacker can send
-* X-Forwarded-Host: evil.com and poison any redirect that resolves
-* against request.url.
-*
-* On Cloudflare Workers, X-Forwarded-Host is always set by Cloudflare
-* itself, so this is only a concern for the Node.js prod-server.
-*/
-function resolveHost(req, fallback) {
-	const rawForwarded = req.headers["x-forwarded-host"];
-	const hostHeader = req.headers.host;
-	if (rawForwarded) {
-		const forwardedHost = rawForwarded.split(",")[0].trim().toLowerCase();
-		if (forwardedHost && trustedHosts.has(forwardedHost)) return forwardedHost;
-	}
-	return hostHeader || fallback;
-}
-/** Hosts that are allowed as X-Forwarded-Host values (stored lowercase). */
-const trustedHosts = new Set((process.env.VINEXT_TRUSTED_HOSTS ?? "").split(",").map((h) => h.trim().toLowerCase()).filter(Boolean));
-/**
-* Whether to trust X-Forwarded-Proto from upstream proxies.
-* Enabled when VINEXT_TRUST_PROXY=1 or when VINEXT_TRUSTED_HOSTS is set
-* (having trusted hosts implies a trusted proxy).
-*/
-const trustProxy = process.env.VINEXT_TRUST_PROXY === "1" || trustedHosts.size > 0;
-/**
 * Convert a Node.js IncomingMessage to a Web Request object.
 *
 * When `urlOverride` is provided, it is used as the path + query string
@@ -462,17 +450,14 @@ const trustProxy = process.env.VINEXT_TRUST_PROXY === "1" || trustedHosts.size >
 * Router prod server normalizes before static-asset lookup, and can pass
 * the result here so the downstream RSC handler doesn't re-normalize).
 */
-function nodeToWebRequest(req, urlOverride) {
-	const rawProto = trustProxy ? req.headers["x-forwarded-proto"]?.split(",")[0]?.trim() : void 0;
-	const origin = `${rawProto === "https" || rawProto === "http" ? rawProto : "http"}://${resolveHost(req, "localhost")}`;
+function nodeToWebRequest(req, urlOverride, prerenderSecret) {
+	const origin = `${resolveRequestProtocol(req)}://${resolveRequestHost(req, "localhost")}`;
 	const url = new URL(urlOverride ?? req.url ?? "/", origin);
-	const rawHeaders = new Headers();
-	for (const [key, value] of Object.entries(req.headers)) {
-		if (value === void 0) continue;
-		if (Array.isArray(value)) for (const v of value) rawHeaders.append(key, v);
-		else rawHeaders.set(key, value);
-	}
+	const rawHeaders = nodeHeadersToWebHeaders(req.headers);
+	const prerenderRouteParamsPayload = readTrustedPrerenderRouteParamsFromHeaders(rawHeaders, prerenderSecret);
 	const headers = filterInternalHeaders(rawHeaders);
+	const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
+	if (prerenderRouteParamsHeader !== null) headers.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
 	const method = req.method ?? "GET";
 	const hasBody = method !== "GET" && method !== "HEAD";
 	const init = {
@@ -584,6 +569,22 @@ function resolveAppRouterHandler(entry) {
 	console.error("[vinext] App Router entry must export either a default handler function or a Worker-style default export with fetch()");
 	process.exit(1);
 }
+function isAppRouterPrerenderSeederExport(value) {
+	return typeof value === "function";
+}
+function resolveAppRouterPrerenderSeeder(entryModule) {
+	if (typeof entryModule !== "object" || entryModule === null) return seedMemoryCacheFromPrerender;
+	const seedExport = Object.getOwnPropertyDescriptor(entryModule, "seedMemoryCacheFromPrerender")?.value;
+	if (!isAppRouterPrerenderSeederExport(seedExport)) {
+		if (process.env.NEXT_PRIVATE_DEBUG_CACHE) console.debug("[vinext] ISR: using fallback prerender cache seeder");
+		return seedMemoryCacheFromPrerender;
+	}
+	if (process.env.NEXT_PRIVATE_DEBUG_CACHE) console.debug("[vinext] ISR: using App Router entry prerender cache seeder");
+	return async (serverDir) => {
+		const result = await Promise.resolve(seedExport(serverDir));
+		return typeof result === "number" ? result : 0;
+	};
+}
 /**
 * Resolve a request pathname to a static-asset lookup path inside `clientDir`.
 *
@@ -592,27 +593,21 @@ function resolveAppRouterHandler(entry) {
 *
 * Three URL shapes are recognised:
 *
-*  - `/assets/...` — the historical Vite default, used when `assetPrefix` is
-*    unset. Returns the pathname verbatim.
+*  - `/_next/static/...` — the default layout. Files land on disk at
+*    `dist/client/_next/static/...`, so the pathname maps 1:1. Also covers
+*    absolute-URL `assetPrefix` with no path component (same on-disk and
+*    URL shape).
 *  - `<assetPathPrefix>/_next/static/...` — when `assetPrefix` is a path
 *    prefix (e.g. `/custom-asset-prefix`). The on-disk layout is
 *    `dist/client/<prefix>/_next/static/...`, so the pathname maps 1:1.
-*  - `/_next/static/...` — when `assetPrefix` is an absolute URL with no
-*    path component (e.g. `https://cdn.example.com`). Files land on disk
-*    at `dist/client/_next/static/...`. This branch is mostly a fallback
-*    for setups that don't actually route asset requests to the CDN.
-*
-* When `assetPrefix` is an absolute URL with a non-empty pathname
-* (e.g. `https://cdn.example.com/sub`), files are written to
-* `dist/client/_next/static/...` but emitted URLs prepend the full URL
-* (`https://cdn.example.com/sub/_next/static/...`). Requests for those
-* URLs do not normally arrive at this server — they go to the CDN. We
-* still accept `<pathname>/_next/static/...` so a same-origin reverse
-* proxy can route through.
+*  - `<absoluteURLPathname>/_next/static/...` — when `assetPrefix` is an
+*    absolute URL with a non-empty pathname (e.g. `https://cdn/sub`).
+*    Files are written to `dist/client/_next/static/...` but emitted URLs
+*    prepend the full URL. Requests do not normally arrive here — they go
+*    to the CDN — but we accept them so a same-origin reverse proxy can
+*    route through; the on-disk path is just `_next/static/...`.
 */
 function resolveAppRouterAssetPath(pathname, assetPathPrefix, assetPrefix) {
-	if (pathname.startsWith("/assets/")) return pathname;
-	if (!assetPrefix) return null;
 	const nextStaticDir = `/${ASSET_PREFIX_URL_DIR}/`;
 	if (assetPathPrefix) {
 		if (pathname === assetPathPrefix || pathname.startsWith(assetPathPrefix + "/")) {
@@ -657,7 +652,7 @@ async function startAppRouterServer(options) {
 	const rscHandler = resolveAppRouterHandler(rscModule.default);
 	const appRouterAssetPrefix = typeof rscModule.__assetPrefix === "string" ? rscModule.__assetPrefix : "";
 	const appAssetPathPrefix = assetPrefixPathname(appRouterAssetPrefix);
-	const seededRoutes = await seedMemoryCacheFromPrerender(path.dirname(rscEntryPath));
+	const seededRoutes = await resolveAppRouterPrerenderSeeder(rscModule)(path.dirname(rscEntryPath));
 	if (seededRoutes > 0) console.log(`[vinext] Seeded ${seededRoutes} pre-rendered route${seededRoutes !== 1 ? "s" : ""} into memory cache`);
 	const staticCache = await StaticFileCache.create(clientDir);
 	const handleRequest = async (req, res) => {
@@ -687,9 +682,14 @@ async function startAppRouterServer(options) {
 		}
 		{
 			const assetLookupPath = resolveAppRouterAssetPath(pathname, appAssetPathPrefix, appRouterAssetPrefix);
-			if (assetLookupPath && await tryServeStatic(req, res, clientDir, assetLookupPath, compress, staticCache)) return;
+			if (assetLookupPath) {
+				if (await tryServeStatic(req, res, clientDir, assetLookupPath, compress, staticCache)) return;
+				res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+				res.end("Not Found");
+				return;
+			}
 		}
-		if (pathname === "/_vinext/image") {
+		if (isImageOptimizationPath(pathname)) {
 			const params = parseImageParams(new URL(rawUrl, "http://localhost"), [...DEFAULT_DEVICE_SIZES, ...DEFAULT_IMAGE_SIZES]);
 			if (!params) {
 				res.writeHead(400);
@@ -713,7 +713,7 @@ async function startAppRouterServer(options) {
 		}
 		try {
 			const qs = rawUrl.includes("?") ? rawUrl.slice(rawUrl.indexOf("?")) : "";
-			const response = await rscHandler(nodeToWebRequest(req, pathname + qs));
+			const response = await rscHandler(nodeToWebRequest(req, pathname + qs, prerenderSecret));
 			const staticFileSignal = response.headers.get(VINEXT_STATIC_FILE_HEADER);
 			if (staticFileSignal) {
 				let staticFilePath = "/";
@@ -775,7 +775,7 @@ function readPagesServerEntryPageRoutes(value) {
 *
 * Uses the server entry (dist/server/entry.js) which exports:
 * - renderPage(request, url, manifest, ctx?, middlewareHeaders?) — SSR rendering (Web Request → Response)
-* - handleApiRoute(request, url) — API route handling (Web Request → Response)
+* - handleApiRoute(request, url, ctx?) — API route handling (ctx optional; pass for ctx.waitUntil() on Workers)
 * - runMiddleware(request, ctx?) — middleware execution (ctx optional; pass for ctx.waitUntil() on Workers)
 * - vinextConfig — embedded next.config.js settings
 */
@@ -783,7 +783,7 @@ async function startPagesRouterServer(options) {
 	const { port, host, clientDir, serverEntryPath, compress, purpose } = options;
 	const serverMtime = fs.statSync(serverEntryPath).mtimeMs;
 	const serverEntry = await import(`${pathToFileURL(serverEntryPath).href}?t=${serverMtime}`);
-	const { renderPage, handleApiRoute: handleApi, runMiddleware, vinextConfig } = serverEntry;
+	const { renderPage, handleApiRoute: handleApi, runMiddleware, vinextConfig, buildId: pagesBuildId } = serverEntry;
 	const matchPageRoute = typeof serverEntry.matchPageRoute === "function" ? serverEntry.matchPageRoute : void 0;
 	const pageRoutes = readPagesServerEntryPageRoutes(serverEntry.pageRoutes);
 	const prerenderSecret = readPrerenderSecret(path.dirname(serverEntryPath));
@@ -792,6 +792,7 @@ async function startPagesRouterServer(options) {
 	const pagesAssetPathPrefix = assetPrefixPathname(assetPrefix);
 	const assetBase = basePath ? `${basePath}/` : "/";
 	const trailingSlash = vinextConfig?.trailingSlash ?? false;
+	const i18nConfig = vinextConfig?.i18n ?? null;
 	const configRedirects = vinextConfig?.redirects ?? [];
 	const configRewrites = vinextConfig?.rewrites ?? {
 		beforeFiles: [],
@@ -867,8 +868,13 @@ async function startPagesRouterServer(options) {
 		}
 		const staticLookupPath = stripBasePath(pathname, basePath);
 		const pagesAssetLookup = resolveAppRouterAssetPath(pathname, pagesAssetPathPrefix, assetPrefix);
-		if (pagesAssetLookup && await tryServeStatic(req, res, clientDir, pagesAssetLookup, compress, staticCache)) return;
-		if (pathname === "/_vinext/image" || staticLookupPath === "/_vinext/image") {
+		if (pagesAssetLookup) {
+			if (await tryServeStatic(req, res, clientDir, pagesAssetLookup, compress, staticCache)) return;
+			res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+			res.end("Not Found");
+			return;
+		}
+		if (isImageOptimizationPath(pathname) || isImageOptimizationPath(staticLookupPath)) {
 			const params = parseImageParams(new URL(rawUrl, "http://localhost"), allowedImageWidths);
 			if (!params) {
 				res.writeHead(400);
@@ -891,6 +897,7 @@ async function startPagesRouterServer(options) {
 			return;
 		}
 		try {
+			const hadBasePath = !basePath || hasBasePath(pathname, basePath);
 			{
 				const stripped = stripBasePath(pathname, basePath);
 				if (stripped !== pathname) {
@@ -898,27 +905,37 @@ async function startPagesRouterServer(options) {
 					pathname = stripped;
 				}
 			}
-			if (pathname !== "/" && pathname !== "/api" && !pathname.startsWith("/api/")) {
-				const hasTrailing = pathname.endsWith("/");
-				if (trailingSlash && !hasTrailing) {
-					const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
-					res.writeHead(308, { Location: basePath + pathname + "/" + qs });
+			const basePathState = {
+				basePath,
+				hadBasePath
+			};
+			{
+				const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+				const trailingSlashRedirect = normalizeTrailingSlash(pathname, basePath, trailingSlash, qs);
+				if (trailingSlashRedirect) {
+					const location = trailingSlashRedirect.headers.get("Location");
+					res.writeHead(trailingSlashRedirect.status, location ? { Location: location } : void 0);
 					res.end();
 					return;
-				} else if (!trailingSlash && hasTrailing) {
-					const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
-					res.writeHead(308, { Location: basePath + removeTrailingSlash(pathname) + qs });
-					res.end();
+				}
+			}
+			let isDataReq = false;
+			if (isNextDataPathname(pathname)) {
+				const dataMatch = pagesBuildId ? parseNextDataPathname(pathname, pagesBuildId) : null;
+				if (!dataMatch) {
+					await sendWebResponse(buildNextDataNotFoundResponse(), req, res, compress);
 					return;
 				}
+				isDataReq = true;
+				const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+				url = dataMatch.pagePathname + qs;
+				pathname = dataMatch.pagePathname;
 			}
-			const rawProtocol = trustProxy ? req.headers["x-forwarded-proto"]?.split(",")[0]?.trim() : void 0;
-			const protocol = rawProtocol === "https" || rawProtocol === "http" ? rawProtocol : "http";
-			const hostHeader = resolveHost(req, `${host}:${port}`);
-			const reqHeaders = filterInternalHeaders(Object.entries(req.headers).reduce((h, [k, v]) => {
-				if (v) h.set(k, Array.isArray(v) ? v.join(", ") : v);
-				return h;
-			}, new Headers()));
+			const protocol = resolveRequestProtocol(req);
+			const hostHeader = resolveRequestHost(req, `${host}:${port}`);
+			const rawReqHeaders = nodeHeadersToWebHeaders(req.headers);
+			const isDataRequest = rawReqHeaders.get("x-nextjs-data") === "1";
+			const reqHeaders = filterInternalHeaders(rawReqHeaders);
 			const method = req.method ?? "GET";
 			const hasBody = method !== "GET" && method !== "HEAD";
 			let webRequest = new Request(`${protocol}://${hostHeader}${url}`, {
@@ -928,10 +945,12 @@ async function startPagesRouterServer(options) {
 				duplex: hasBody ? "half" : void 0
 			});
 			const reqCtx = requestContextFromRequest(webRequest);
+			const requestHostname = i18nConfig ? new URL(webRequest.url).hostname : "";
+			const matchPathname = i18nConfig ? normalizeDefaultLocalePathname(pathname, i18nConfig, { hostname: requestHostname }) : pathname;
 			if (configRedirects.length) {
-				const redirect = matchRedirect(pathname, configRedirects, reqCtx);
+				const redirect = matchRedirect(matchPathname, configRedirects, reqCtx, basePathState);
 				if (redirect) {
-					const dest = sanitizeDestination(basePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, basePath) ? basePath + redirect.destination : redirect.destination);
+					const dest = sanitizeDestination(basePath && hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, basePath) ? basePath + redirect.destination : redirect.destination);
 					res.writeHead(redirect.permanent ? 308 : 307, { Location: dest });
 					res.end();
 					return;
@@ -941,7 +960,7 @@ async function startPagesRouterServer(options) {
 			const middlewareHeaders = {};
 			let middlewareStatus;
 			if (typeof runMiddleware === "function") {
-				const result = await runMiddleware(webRequest, void 0);
+				const result = await runMiddleware(webRequest, void 0, { isDataRequest });
 				if (result.waitUntilPromises && result.waitUntilPromises.length > 0) Promise.allSettled(result.waitUntilPromises);
 				if (!result.continue) {
 					if (result.redirectUrl) {
@@ -983,30 +1002,41 @@ async function startPagesRouterServer(options) {
 			const { postMwReqCtx, request: postMwReq } = applyMiddlewareRequestHeaders(middlewareHeaders, webRequest, { preserveCredentialHeaders: isExternalUrl(resolvedUrl) });
 			webRequest = postMwReq;
 			let resolvedPathname = resolvedUrl.split("?")[0];
+			const matchResolvedPathname = (p) => i18nConfig ? normalizeDefaultLocalePathname(p, i18nConfig, { hostname: requestHostname }) : p;
 			if (configHeaders.length) applyConfigHeadersToHeaderRecord(middlewareHeaders, {
 				configHeaders,
-				pathname,
-				requestContext: reqCtx
+				pathname: matchPathname,
+				requestContext: reqCtx,
+				basePathState
 			});
 			if (isExternalUrl(resolvedUrl)) {
 				await sendWebResponse(mergeWebResponse(middlewareHeaders, await proxyExternalRequest(webRequest, resolvedUrl), void 0), req, res, compress);
 				return;
 			}
-			if (staticLookupPath !== "/" && !staticLookupPath.startsWith("/api/") && !staticLookupPath.startsWith("/assets/") && await tryServeStatic(req, res, clientDir, staticLookupPath, compress, staticCache, middlewareHeaders)) return;
+			if (staticLookupPath !== "/" && !staticLookupPath.startsWith("/api/") && !staticLookupPath.startsWith(`/_next/static/`) && await tryServeStatic(req, res, clientDir, staticLookupPath, compress, staticCache, middlewareHeaders)) return;
+			let configRewriteFired = false;
 			if (configRewrites.beforeFiles?.length) {
-				const rewritten = matchRewrite(resolvedPathname, configRewrites.beforeFiles, postMwReqCtx);
+				const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.beforeFiles, postMwReqCtx, basePathState);
 				if (rewritten) {
 					if (isExternalUrl(rewritten)) {
 						await sendWebResponse(await proxyExternalRequest(webRequest, rewritten), req, res, compress);
 						return;
 					}
-					resolvedUrl = rewritten;
-					resolvedPathname = rewritten.split("?")[0];
+					resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
+					resolvedPathname = resolvedUrl.split("?")[0];
+					configRewriteFired = true;
 				}
 			}
-			if (resolvedPathname.startsWith("/api/") || resolvedPathname === "/api") {
+			if (basePath && !hadBasePath && !configRewriteFired) {
+				res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+				res.end("This page could not be found");
+				return;
+			}
+			const apiLookupUrl = stripI18nLocaleForApiRoute(resolvedUrl, vinextConfig?.i18n ?? null);
+			const apiLookupPathname = apiLookupUrl.split("?")[0];
+			if (apiLookupPathname.startsWith("/api/") || apiLookupPathname === "/api") {
 				let response;
-				if (typeof handleApi === "function") response = await handleApi(webRequest, resolvedUrl);
+				if (typeof handleApi === "function") response = await handleApi(webRequest, apiLookupUrl, createNodeExecutionContext());
 				else response = new Response("404 - API route not found", { status: 404 });
 				const mergedResponse = mergeWebResponse(middlewareHeaders, response, middlewareStatus);
 				if (!mergedResponse.body) {
@@ -1022,30 +1052,36 @@ async function startPagesRouterServer(options) {
 			}
 			const pageMatch = matchPageRoute ? matchPageRoute(resolvedPathname, webRequest) : null;
 			if ((!pageMatch || pageMatch.route.isDynamic) && configRewrites.afterFiles?.length) {
-				const rewritten = matchRewrite(resolvedPathname, configRewrites.afterFiles, postMwReqCtx);
+				const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.afterFiles, postMwReqCtx, basePathState);
 				if (rewritten) {
 					if (isExternalUrl(rewritten)) {
 						await sendWebResponse(await proxyExternalRequest(webRequest, rewritten), req, res, compress);
 						return;
 					}
-					resolvedUrl = rewritten;
-					resolvedPathname = rewritten.split("?")[0];
+					resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
+					resolvedPathname = resolvedUrl.split("?")[0];
 				}
 			}
 			let response;
 			if (typeof renderPage === "function") {
 				const middlewareResponseHeaders = toWebHeaders(middlewareHeaders);
-				response = await renderPage(webRequest, resolvedUrl, ssrManifest, void 0, middlewareResponseHeaders);
-				if (response && response.status === 404 && configRewrites.fallback?.length) {
-					const fallbackRewrite = matchRewrite(resolvedPathname, configRewrites.fallback, postMwReqCtx);
+				const renderPageMatch = matchPageRoute ? matchPageRoute(resolvedPathname, webRequest) : null;
+				const shouldDeferErrorPageOnMiss = !isDataReq && !!matchPageRoute && !renderPageMatch;
+				const dataRenderOptions = isDataReq ? { isDataReq: true } : void 0;
+				response = await renderPage(webRequest, resolvedUrl, ssrManifest, void 0, middlewareResponseHeaders, shouldDeferErrorPageOnMiss ? { renderErrorPageOnMiss: false } : dataRenderOptions);
+				let matchedFallbackRewrite = false;
+				if (response && response.status === 404 && shouldDeferErrorPageOnMiss && configRewrites.fallback?.length) {
+					const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.fallback, postMwReqCtx, basePathState);
 					if (fallbackRewrite) {
 						if (isExternalUrl(fallbackRewrite)) {
 							await sendWebResponse(await proxyExternalRequest(webRequest, fallbackRewrite), req, res, compress);
 							return;
 						}
-						response = await renderPage(webRequest, fallbackRewrite, ssrManifest, void 0, middlewareResponseHeaders);
+						matchedFallbackRewrite = true;
+						response = await renderPage(webRequest, mergeRewriteQuery(resolvedUrl, fallbackRewrite), ssrManifest, void 0, middlewareResponseHeaders, dataRenderOptions);
 					}
 				}
+				if (response && response.status === 404 && shouldDeferErrorPageOnMiss && !matchedFallbackRewrite) response = await renderPage(webRequest, resolvedUrl, ssrManifest, void 0, middlewareResponseHeaders);
 			}
 			if (!response) {
 				res.writeHead(404);
@@ -1088,6 +1124,6 @@ async function startPagesRouterServer(options) {
 	};
 }
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
 
 //# sourceMappingURL=prod-server.js.map