vinext 0.1.0 → 0.1.2

package/dist/server/prod-server.js

@@ -2,22 +2,20 @@ import { normalizePathnameForRouteMatchStrict } from "../routing/utils.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, normalizeTrailingSlash } from "./request-pipeline.js";
-import { mergeRewriteQuery } from "../utils/query.js";
-import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
+import { filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
+import { isUnknownRecord } from "../utils/record.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, resolveAssetsDir } from "../utils/asset-prefix.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 { collectInlineCssManifest } from "../build/inline-css.js";
-import { manifestFileWithBase } from "../utils/manifest-paths.js";
+import { mergeHeaders } from "./worker-utils.js";
+import { runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
 import { readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
-import { computeLazyChunks } from "../utils/lazy-chunks.js";
-import { findClientEntryFile, readClientBuildManifest } from "../utils/client-build-manifest.js";
+import { computeClientRuntimeMetadata } from "../utils/client-runtime-metadata.js";
 import { readPrerenderSecret } from "../build/server-manifest.js";
 import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
 import fs from "node:fs";
@@ -47,6 +45,68 @@ import { Readable, pipeline } from "node:stream";
 * - dist/server/index.js — RSC entry (default export: handler(Request) → Response)
 * - dist/server/ssr/index.js — SSR entry (imported by RSC entry at runtime)
 */
+/**
+* mtime of the build each bare (query-less) server-entry URL was first
+* imported from in this process. Node's ESM cache pins a bare URL to that
+* build forever, so rebuilds to the same path must be detected and loaded
+* through a cache-busted URL instead.
+*/
+const bareServerEntryMtimes = /* @__PURE__ */ new Map();
+/**
+* Import a built server entry module (App Router RSC entry or Pages Router
+* server entry) by absolute file path.
+*
+* The first import of a given path uses the plain file:// URL with NO query
+* string. This is load-bearing: code-split builds emit lazy chunks that
+* import the entry back by bare specifier (default Vite builds on both
+* supported majors — Rollup on Vite 7 and Rolldown on Vite 8 — hoist modules
+* shared between the entry's static graph and lazy route chunks into the
+* entry chunk, which the chunks then import as e.g. "../../index.js").
+* Node keys its ESM cache on the full URL including the query string, so if
+* the server imported the entry as `index.js?t=<mtime>`, a chunk's bare
+* back-import would evaluate the entire server bundle a second time and
+* module-level singletons (db pools, service registries) would silently
+* diverge between the two copies. See
+* https://github.com/cloudflare/vinext/issues/1923.
+*
+* A `?t=<mtime>` query string is appended only when the same path is
+* imported again after a rebuild (different mtime) — e.g. test suites that
+* rebuild a fixture to the same output path within one process — where the
+* bare URL's cache entry would return the stale previous build. Note this
+* rebuild branch trades the single-instance guarantee back: chunks that
+* import the entry by bare path still resolve to the FIRST build's cache
+* entry, so freshness and single-instance only hold together on the first
+* import of a path. Production processes import each entry path exactly
+* once and always get both.
+*
+* The entry is imported via its canonical real path: the bundler
+* canonicalizes module ids with fs.realpathSync.native, so chunks evaluate
+* under realpath-based URLs and their relative imports resolve to realpath
+* URLs too. Importing the entry through a symlinked path (macOS /var/...
+* tmpdirs, symlinked deploy directories) would otherwise create a second
+* instance keyed on the symlinked URL.
+*
+* Exported for direct unit testing of the URL choice.
+*/
+function resolveServerEntryImportUrl(entryPath) {
+	let canonicalEntryPath;
+	try {
+		canonicalEntryPath = fs.realpathSync.native(entryPath);
+	} catch {
+		canonicalEntryPath = entryPath;
+	}
+	const href = pathToFileURL(canonicalEntryPath).href;
+	const mtime = fs.statSync(canonicalEntryPath).mtimeMs;
+	const bareMtime = bareServerEntryMtimes.get(href);
+	if (bareMtime === void 0 || bareMtime === mtime) {
+		bareServerEntryMtimes.set(href, mtime);
+		return href;
+	}
+	return `${href}?t=${mtime}`;
+}
+async function importServerEntryModule(entryPath) {
+	return import(resolveServerEntryImportUrl(entryPath));
+}
 /** Convert a Node.js IncomingMessage into a ReadableStream for Web Request body. */
 function readNodeStream(req) {
 	return new ReadableStream({ start(controller) {
@@ -157,12 +217,14 @@ const NO_BODY_RESPONSE_STATUSES = new Set([
 	205,
 	304
 ]);
-function hasHeader(headersRecord, name) {
-	const target = name.toLowerCase();
-	return Object.keys(headersRecord).some((key) => key.toLowerCase() === target);
-}
-function omitHeadersCaseInsensitive(headersRecord, names) {
-	const targets = new Set(names.map((name) => name.toLowerCase()));
+const OMIT_BODY_HEADERS = new Set(["content-length", "content-type"]);
+const OMIT_STATIC_RESPONSE_HEADERS = new Set([
+	VINEXT_STATIC_FILE_HEADER,
+	"content-encoding",
+	"content-length",
+	"content-type"
+]);
+function omitHeadersCaseInsensitive(headersRecord, targets) {
 	const filtered = {};
 	for (const [key, value] of Object.entries(headersRecord)) {
 		if (targets.has(key.toLowerCase())) continue;
@@ -175,9 +237,14 @@ function matchesIfNoneMatchHeader(ifNoneMatch, etag) {
 	if (ifNoneMatch === "*") return true;
 	return ifNoneMatch.split(",").map((value) => value.trim()).some((value) => value === etag);
 }
-function stripHeaders(headersRecord, names) {
-	const targets = new Set(names.map((name) => name.toLowerCase()));
-	for (const key of Object.keys(headersRecord)) if (targets.has(key.toLowerCase())) delete headersRecord[key];
+function installClientBuildManifestGlobals(clientDir, assetBase, assetPrefix) {
+	const metadata = computeClientRuntimeMetadata({
+		clientDir,
+		assetBase,
+		assetPrefix
+	});
+	globalThis.__VINEXT_LAZY_CHUNKS__ = metadata.lazyChunks;
+	globalThis.__VINEXT_DYNAMIC_PRELOADS__ = metadata.dynamicPreloads;
 }
 function isNoBodyResponseStatus(status) {
 	return NO_BODY_RESPONSE_STATUSES.has(status);
@@ -201,36 +268,15 @@ function logProdServerStarted(host, port, purpose) {
 /**
 * Merge middleware/config headers and an optional status override into a new
 * Web Response while preserving the original body stream when allowed.
-* Keep this in sync with server/worker-utils.ts and the generated copy in
-* deploy.ts.
+*
+* This is the canonical {@link mergeHeaders} (server/worker-utils.ts) with the
+* arguments in (headers, response) order. The request path now calls
+* `runPagesRequest`, which uses `mergeHeaders` directly; this wrapper is retained
+* only for its existing tests and any external callers, so there is a single
+* implementation to keep in sync. (deploy.ts still emits its own generated copy.)
 */
 function mergeWebResponse(middlewareHeaders, response, statusOverride) {
-	const filteredMiddlewareHeaders = omitHeadersCaseInsensitive(middlewareHeaders, ["content-length"]);
-	const status = statusOverride ?? response.status;
-	const mergedHeaders = mergeResponseHeaders(filteredMiddlewareHeaders, response);
-	const shouldDropBody = isNoBodyResponseStatus(status);
-	const shouldStripStreamLength = isVinextStreamedHtmlResponse(response) && hasHeader(mergedHeaders, "content-length");
-	if (!Object.keys(filteredMiddlewareHeaders).length && statusOverride === void 0 && !shouldDropBody && !shouldStripStreamLength) return response;
-	if (shouldDropBody) {
-		cancelResponseBody(response);
-		stripHeaders(mergedHeaders, [
-			"content-encoding",
-			"content-length",
-			"content-type",
-			"transfer-encoding"
-		]);
-		return new Response(null, {
-			status,
-			statusText: status === response.status ? response.statusText : void 0,
-			headers: toWebHeaders(mergedHeaders)
-		});
-	}
-	if (shouldStripStreamLength) stripHeaders(mergedHeaders, ["content-length"]);
-	return new Response(response.body, {
-		status,
-		statusText: status === response.status ? response.statusText : void 0,
-		headers: toWebHeaders(mergedHeaders)
-	});
+	return mergeHeaders(response, middlewareHeaders, statusOverride);
 }
 /**
 * Send a compressed response if the content type is compressible and the
@@ -240,7 +286,7 @@ function sendCompressed(req, res, body, contentType, statusCode, extraHeaders =
 	const buf = typeof body === "string" ? Buffer.from(body) : body;
 	const baseType = contentType.split(";")[0].trim();
 	const encoding = compress ? negotiateEncoding(req) : null;
-	const headersWithoutBodyHeaders = omitHeadersCaseInsensitive(extraHeaders, ["content-length", "content-type"]);
+	const headersWithoutBodyHeaders = omitHeadersCaseInsensitive(extraHeaders, OMIT_BODY_HEADERS);
 	const writeHead = (headers) => {
 		if (statusText) res.writeHead(statusCode, statusText, headers);
 		else res.writeHead(statusCode, headers);
@@ -624,6 +670,40 @@ function resolveAppRouterAssetPath(pathname, assetPathPrefix, assetPrefix) {
 	if (pathname.startsWith(nextStaticDir)) return pathname;
 	return null;
 }
+function isSsrManifest(value) {
+	if (!isUnknownRecord(value)) return false;
+	return Object.values(value).every((files) => Array.isArray(files) && files.every((file) => typeof file === "string"));
+}
+function readSsrManifest(clientDir) {
+	const manifestPath = path.join(clientDir, ".vite", "ssr-manifest.json");
+	if (!fs.existsSync(manifestPath)) return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+	} catch (error) {
+		console.warn(`[vinext] Ignoring unparseable SSR manifest at ${manifestPath}:`, error);
+		return {};
+	}
+	if (!isSsrManifest(parsed)) {
+		console.warn(`[vinext] Ignoring SSR manifest with unexpected shape at ${manifestPath}`);
+		return {};
+	}
+	return parsed;
+}
+function installPagesClientAssetGlobals(options) {
+	const ssrManifest = readSsrManifest(options.clientDir);
+	globalThis.__VINEXT_SSR_MANIFEST__ = Object.keys(ssrManifest).length > 0 ? ssrManifest : void 0;
+	const metadata = computeClientRuntimeMetadata({
+		clientDir: options.clientDir,
+		assetBase: options.assetBase,
+		assetPrefix: options.assetPrefix,
+		includeClientEntry: options.clientEntryLookup === "pages-client-entry" ? "pages-client-entry" : true
+	});
+	globalThis.__VINEXT_CLIENT_ENTRY__ = metadata.clientEntryFile;
+	globalThis.__VINEXT_LAZY_CHUNKS__ = metadata.lazyChunks;
+	globalThis.__VINEXT_DYNAMIC_PRELOADS__ = metadata.dynamicPreloads;
+	return ssrManifest;
+}
 /**
 * Start the App Router production server.
 *
@@ -649,13 +729,22 @@ async function startAppRouterServer(options) {
 		imageConfig = JSON.parse(fs.readFileSync(imageConfigPath, "utf-8"));
 	} catch {}
 	const prerenderSecret = readPrerenderSecret(path.dirname(rscEntryPath));
-	const rscMtime = fs.statSync(rscEntryPath).mtimeMs;
-	const rscModule = await import(`${pathToFileURL(rscEntryPath).href}?t=${rscMtime}`);
+	const rscModule = await importServerEntryModule(rscEntryPath);
 	const rscHandler = resolveAppRouterHandler(rscModule.default);
 	const appRouterAssetPrefix = typeof rscModule.__assetPrefix === "string" ? rscModule.__assetPrefix : "";
+	const appRouterBasePath = typeof rscModule.__basePath === "string" ? rscModule.__basePath : "";
 	const appRouterInlineCss = rscModule.__inlineCss === true;
+	const appRouterHasPagesDir = rscModule.__hasPagesDir === true;
 	globalThis.__VINEXT_INLINE_CSS__ = appRouterInlineCss ? collectInlineCssManifest(clientDir, appRouterAssetPrefix) : void 0;
 	const appAssetPathPrefix = assetPrefixPathname(appRouterAssetPrefix);
+	const appAssetBase = appRouterBasePath ? `${appRouterBasePath}/` : "/";
+	if (appRouterHasPagesDir) installPagesClientAssetGlobals({
+		clientDir,
+		assetPrefix: appRouterAssetPrefix,
+		assetBase: appAssetBase,
+		clientEntryLookup: "pages-client-entry"
+	});
+	else installClientBuildManifestGlobals(clientDir, appAssetBase, appRouterAssetPrefix);
 	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);
@@ -726,12 +815,7 @@ async function startAppRouterServer(options) {
 				} catch {
 					staticFilePath = staticFileSignal;
 				}
-				const staticResponseHeaders = omitHeadersCaseInsensitive(mergeResponseHeaders({}, response), [
-					VINEXT_STATIC_FILE_HEADER,
-					"content-encoding",
-					"content-length",
-					"content-type"
-				]);
+				const staticResponseHeaders = omitHeadersCaseInsensitive(mergeResponseHeaders({}, response), OMIT_STATIC_RESPONSE_HEADERS);
 				const served = await tryServeStatic(req, res, clientDir, staticFilePath, compress, staticCache, staticResponseHeaders, response.status);
 				cancelResponseBody(response);
 				if (served) return;
@@ -785,8 +869,7 @@ function readPagesServerEntryPageRoutes(value) {
 */
 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 serverEntry = await importServerEntryModule(serverEntryPath);
 	const { renderPage, handleApiRoute: handleApi, runMiddleware, vinextConfig, buildId: pagesBuildId } = serverEntry;
 	const matchPageRoute = typeof serverEntry.matchPageRoute === "function" ? serverEntry.matchPageRoute : void 0;
 	const pageRoutes = readPagesServerEntryPageRoutes(serverEntry.pageRoutes);
@@ -811,20 +894,12 @@ async function startPagesRouterServer(options) {
 		contentDispositionType: vinextConfig.images.contentDispositionType,
 		contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
 	} : void 0;
-	let ssrManifest = {};
-	const manifestPath = path.join(clientDir, ".vite", "ssr-manifest.json");
-	if (fs.existsSync(manifestPath)) ssrManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-	const buildManifest = readClientBuildManifest(path.join(clientDir, ".vite", "manifest.json"));
-	globalThis.__VINEXT_CLIENT_ENTRY__ = findClientEntryFile({
-		buildManifest,
+	const ssrManifest = installPagesClientAssetGlobals({
 		clientDir,
-		assetsSubdir: resolveAssetsDir(assetPrefix),
-		assetBase
+		assetPrefix,
+		assetBase,
+		clientEntryLookup: "any-client-entry"
 	});
-	if (buildManifest) {
-		const lazyChunks = computeLazyChunks(buildManifest).map((file) => manifestFileWithBase(file, assetBase));
-		globalThis.__VINEXT_LAZY_CHUNKS__ = lazyChunks.length > 0 ? lazyChunks : void 0;
-	} else globalThis.__VINEXT_LAZY_CHUNKS__ = void 0;
 	const staticCache = await StaticFileCache.create(clientDir);
 	const handleRequest = async (req, res) => {
 		const rawUrl = req.url ?? "/";
@@ -915,20 +990,6 @@ async function startPagesRouterServer(options) {
 					pathname = stripped;
 				}
 			}
-			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;
-				}
-			}
 			let isDataReq = false;
 			if (isNextDataPathname(pathname)) {
 				const dataMatch = pagesBuildId ? parseNextDataPathname(pathname, pagesBuildId) : null;
@@ -948,167 +1009,54 @@ async function startPagesRouterServer(options) {
 			const reqHeaders = filterInternalHeaders(rawReqHeaders);
 			const method = req.method ?? "GET";
 			const hasBody = method !== "GET" && method !== "HEAD";
-			let webRequest = new Request(`${protocol}://${hostHeader}${url}`, {
+			const result = await runPagesRequest(new Request(`${protocol}://${hostHeader}${url}`, {
 				method,
 				headers: reqHeaders,
 				body: hasBody ? readNodeStream(req) : void 0,
 				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(matchPathname, configRedirects, reqCtx, basePathState);
-				if (redirect) {
-					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;
-				}
-			}
-			let resolvedUrl = url;
-			const middlewareHeaders = {};
-			let middlewareStatus;
-			if (typeof runMiddleware === "function") {
-				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) {
-						const redirectHeaders = { Location: result.redirectUrl };
-						if (result.responseHeaders) for (const [key, value] of result.responseHeaders) {
-							const existing = redirectHeaders[key];
-							if (existing === void 0) redirectHeaders[key] = value;
-							else if (Array.isArray(existing)) existing.push(value);
-							else redirectHeaders[key] = [existing, value];
-						}
-						res.writeHead(result.redirectStatus ?? 307, redirectHeaders);
-						res.end();
-						return;
-					}
-					if (result.response) {
-						const body = Buffer.from(await result.response.arrayBuffer());
-						const respHeaders = {};
-						result.response.headers.forEach((value, key) => {
-							if (key === "set-cookie") return;
-							respHeaders[key] = value;
-						});
-						const setCookies = result.response.headers.getSetCookie?.() ?? [];
-						if (setCookies.length > 0) respHeaders["set-cookie"] = setCookies;
-						if (result.response.statusText) res.writeHead(result.response.status, result.response.statusText, respHeaders);
-						else res.writeHead(result.response.status, respHeaders);
-						res.end(body);
-						return;
-					}
-				}
-				if (result.responseHeaders) for (const [key, value] of result.responseHeaders) if (key === "set-cookie") {
-					const existing = middlewareHeaders[key];
-					if (Array.isArray(existing)) existing.push(value);
-					else if (existing) middlewareHeaders[key] = [existing, value];
-					else middlewareHeaders[key] = [value];
-				} else middlewareHeaders[key] = value;
-				if (result.rewriteUrl) resolvedUrl = result.rewriteUrl;
-				middlewareStatus = result.status ?? result.rewriteStatus;
-			}
-			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, {
+			}), {
+				basePath,
+				trailingSlash,
+				i18nConfig,
+				configRedirects,
+				configRewrites,
 				configHeaders,
-				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(`/_next/static/`) && await tryServeStatic(req, res, clientDir, staticLookupPath, compress, staticCache, middlewareHeaders)) return;
-			let configRewriteFired = false;
-			if (configRewrites.beforeFiles?.length) {
-				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 = mergeRewriteQuery(resolvedUrl, rewritten);
-					resolvedPathname = resolvedUrl.split("?")[0];
-					configRewriteFired = true;
+				hadBasePath,
+				isDataReq,
+				isDataRequest,
+				ctx: void 0,
+				rawSearch: rawQs,
+				matchPageRoute: matchPageRoute ?? null,
+				runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) : null,
+				renderPage: typeof renderPage === "function" ? (request, resolvedUrl, options, stagedHeaders) => renderPage(request, resolvedUrl, ssrManifest, void 0, stagedHeaders, options) : null,
+				handleApi: typeof handleApi === "function" ? (request, apiUrl) => handleApi(request, apiUrl, createNodeExecutionContext()) : null,
+				serveStaticFile: async (requestPathname, stagedHeaders) => {
+					if (requestPathname === "/" || requestPathname.startsWith("/api/") || requestPathname.startsWith(`/_next/static/`)) return false;
+					return tryServeStatic(req, res, clientDir, requestPathname, compress, staticCache, stagedHeaders);
 				}
-			}
-			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, apiLookupUrl, createNodeExecutionContext());
-				else response = new Response("404 - API route not found", { status: 404 });
-				const mergedResponse = mergeWebResponse(middlewareHeaders, response, middlewareStatus);
-				if (!mergedResponse.body) {
-					await sendWebResponse(mergedResponse, req, res, compress);
+			});
+			if (result.type === "handled") return;
+			if (result.type === "response") {
+				const { response } = result;
+				if (isVinextStreamedHtmlResponse(response) || !response.body || result.defaultContentType === void 0) {
+					await sendWebResponse(response, req, res, compress);
 					return;
 				}
-				const responseBody = Buffer.from(await mergedResponse.arrayBuffer());
-				const ct = mergedResponse.headers.get("content-type") ?? "application/octet-stream";
-				const responseHeaders = mergeResponseHeaders({}, mergedResponse);
-				const finalStatusText = mergedResponse.statusText || void 0;
-				sendCompressed(req, res, responseBody, ct, mergedResponse.status, responseHeaders, compress, finalStatusText);
-				return;
-			}
-			const pageMatch = matchPageRoute ? matchPageRoute(resolvedPathname, webRequest) : null;
-			if ((!pageMatch || pageMatch.route.isDynamic) && configRewrites.afterFiles?.length) {
-				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 = mergeRewriteQuery(resolvedUrl, rewritten);
-					resolvedPathname = resolvedUrl.split("?")[0];
-				}
-			}
-			let response;
-			if (typeof renderPage === "function") {
-				const middlewareResponseHeaders = toWebHeaders(middlewareHeaders);
-				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;
-						}
-						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);
-				res.end("This page could not be found");
-				return;
-			}
-			const shouldStreamPagesResponse = isVinextStreamedHtmlResponse(response);
-			const mergedResponse = mergeWebResponse(middlewareHeaders, response, middlewareStatus);
-			if (shouldStreamPagesResponse || !mergedResponse.body) {
-				await sendWebResponse(mergedResponse, req, res, compress);
+				const responseBody = Buffer.from(await response.arrayBuffer());
+				const ct = response.headers.get("content-type") ?? result.defaultContentType;
+				const responseHeaders = {};
+				response.headers.forEach((v, k) => {
+					if (k === "set-cookie") return;
+					responseHeaders[k] = v;
+				});
+				const setCookies = response.headers.getSetCookie?.() ?? [];
+				if (setCookies.length > 0) responseHeaders["set-cookie"] = setCookies;
+				const finalStatusText = response.statusText || void 0;
+				sendCompressed(req, res, responseBody, ct, response.status, responseHeaders, compress, finalStatusText);
 				return;
 			}
-			const responseBody = Buffer.from(await mergedResponse.arrayBuffer());
-			const ct = mergedResponse.headers.get("content-type") ?? "text/html";
-			const responseHeaders = mergeResponseHeaders({}, mergedResponse);
-			const finalStatusText = mergedResponse.statusText || void 0;
-			sendCompressed(req, res, responseBody, ct, mergedResponse.status, responseHeaders, compress, finalStatusText);
+			res.writeHead(404);
+			res.end("This page could not be found");
 		} catch (e) {
 			console.error("[vinext] Server error:", e);
 			if (!res.headersSent) {
@@ -1134,4 +1082,4 @@ async function startPagesRouterServer(options) {
 	};
 }
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, importServerEntryModule, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, resolveServerEntryImportUrl, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };

package/dist/server/socket-error-backstop.d.ts

@@ -5,6 +5,24 @@
  * Exported for unit testing in isolation (no process-state mutation).
  */
 declare function peerDisconnectCode(err: unknown): string | undefined;
+/**
+ * Pure predicate: returns `true` when `err` is a benign failure from a
+ * dynamic `import()` of a static asset URL — the "URL dependency" pattern
+ * that Next.js tolerates at build time. Two shapes are recognised:
+ *
+ *   - `ERR_UNKNOWN_FILE_EXTENSION`: the asset resolved on disk but is not an
+ *     ES module (e.g. a co-located `./style.css`). The error message ends in
+ *     the offending extension in quotes: `... extension ".css" for /path`.
+ *   - `ERR_MODULE_NOT_FOUND`: the asset URL did not resolve (the chunk lives
+ *     in `dist/server/` but the source asset does not). Node attaches the
+ *     unresolved specifier on `err.url`; we match only when it points at a
+ *     static-asset extension.
+ *
+ * Anything outside this allow-list (including missing `.js`/`.mjs`/`.ts`
+ * modules with no extension) returns `false` so real bugs still crash.
+ * Exported for unit testing in isolation.
+ */
+declare function isBenignAssetImportError(err: unknown): boolean;
 /**
  * Test-only: returns whether the backstop has been installed in this
  * process. Used by the unit test to assert idempotent install via the
@@ -13,4 +31,4 @@ declare function peerDisconnectCode(err: unknown): string | undefined;
 declare function isSocketErrorBackstopInstalled(): boolean;
 declare function installSocketErrorBackstop(): void;
 //#endregion
-export { installSocketErrorBackstop, isSocketErrorBackstopInstalled, peerDisconnectCode };
+export { installSocketErrorBackstop, isBenignAssetImportError, isSocketErrorBackstopInstalled, peerDisconnectCode };