vinext 0.0.55 → 0.1.1

package/dist/server/prerender-route-params.js

@@ -12,7 +12,10 @@ function isPrerenderRouteParams(value) {
 }
 function isPrerenderRouteParamsPayload(value) {
 	if (!isUnknownRecord(value)) return false;
-	if (Object.keys(value).length !== 2) return false;
+	const keys = Object.keys(value);
+	if (keys.length !== 2 && keys.length !== 3) return false;
+	if (keys.some((key) => key !== "fallbackParamNames" && key !== "params" && key !== "routePattern")) return false;
+	if ("fallbackParamNames" in value && (!Array.isArray(value.fallbackParamNames) || !value.fallbackParamNames.every((name) => typeof name === "string"))) return false;
 	return typeof value.routePattern === "string" && value.routePattern.startsWith("/") && isPrerenderRouteParams(value.params);
 }
 function serializePrerenderRouteParamsHeader(payload) {
@@ -62,17 +65,34 @@ function decodedPrerenderRouteParamEquals(prerenderValue, matchedValue) {
 	return decoded !== null && decoded === matchedValue;
 }
 function prerenderRouteParamsPayloadMatchesRoute(payload, routePattern, params) {
-	if (payload === null) return false;
-	if (payload.routePattern !== routePattern) return false;
-	if (Object.keys(payload.params).length !== Object.keys(params).length) return false;
+	return matchPrerenderRouteParamsPayload(payload, routePattern, params)?.kind === "exact";
+}
+function matchPrerenderRouteParamsPayload(payload, routePattern, params) {
+	if (payload === null) return null;
+	if (payload.routePattern !== routePattern) return null;
+	if (Object.keys(payload.params).length !== Object.keys(params).length) return null;
 	for (const [key, prerenderValue] of Object.entries(payload.params)) {
 		const matchedValue = params[key];
-		if (matchedValue === void 0) return false;
-		if (!decodedPrerenderRouteParamEquals(prerenderValue, matchedValue)) return false;
+		if (matchedValue === void 0) return null;
+		if (!decodedPrerenderRouteParamEquals(prerenderValue, matchedValue)) return null;
 	}
-	return true;
+	if (payload.fallbackParamNames) {
+		const routeParamNames = new Set(routePattern.split("/").filter((part) => part.startsWith(":")).map((part) => part.endsWith("+") || part.endsWith("*") ? part.slice(1, -1) : part.slice(1)));
+		const fallbackParamNames = payload.fallbackParamNames.filter((name, index, names) => routeParamNames.has(name) && names.indexOf(name) === index);
+		if (fallbackParamNames.length !== payload.fallbackParamNames.length) return null;
+		if (fallbackParamNames.length === 0) return null;
+		return {
+			fallbackParamNames,
+			kind: "fallback-shell",
+			params: payload.params
+		};
+	}
+	return {
+		kind: "exact",
+		params: payload.params
+	};
 }
-function encodePrerenderRouteParams(pattern, params) {
+function encodePrerenderRouteParams(pattern, params, fallbackParamNames) {
 	const encoded = {};
 	for (const part of pattern.split("/").filter(Boolean)) {
 		let paramName = null;
@@ -84,11 +104,10 @@ function encodePrerenderRouteParams(pattern, params) {
 		else if (typeof value === "string") encoded[paramName] = encodeURIComponent(value);
 	}
 	return Object.keys(encoded).length > 0 ? {
+		...fallbackParamNames && fallbackParamNames.length > 0 ? { fallbackParamNames } : {},
 		routePattern: pattern,
 		params: encoded
 	} : null;
 }
 //#endregion
-export { encodePrerenderRouteParams, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };
-
-//# sourceMappingURL=prerender-route-params.js.map
+export { encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };

package/dist/server/prerender-work-unit-setup.d.ts

@@ -3,5 +3,4 @@ declare function runWithPrerenderWorkUnit<T>(fn: () => Promise<T>, options?: {
   route?: string | (() => string);
 }): Promise<T>;
 //#endregion
-export { runWithPrerenderWorkUnit };
-//# sourceMappingURL=prerender-work-unit-setup.d.ts.map
+export { runWithPrerenderWorkUnit };

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

@@ -26,5 +26,3 @@ function runWithPrerenderWorkUnit(fn, options) {
 }
 //#endregion
 export { runWithPrerenderWorkUnit };
-
-//# sourceMappingURL=prerender-work-unit-setup.js.map

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

@@ -1,6 +1,5 @@
 import { StaticFileCache } from "./static-file-cache.js";
 import { resolveRequestHost, trustProxy, trustedHosts } from "./proxy-trust.js";
-import * as _$node_http0 from "node:http";
 import { IncomingMessage, ServerResponse } from "node:http";
 
 //#region src/server/prod-server.d.ts
@@ -30,8 +29,12 @@ declare function mergeResponseHeaders(middlewareHeaders: Record<string, string |
 /**
  * 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.)
  */
 declare function mergeWebResponse(middlewareHeaders: Record<string, string | string[]>, response: Response, statusOverride?: number): Response;
 /**
@@ -73,7 +76,7 @@ declare function sendWebResponse(webResponse: Response, req: IncomingMessage, re
  * Pages Router (dist/server/entry.js) and configures the appropriate handler.
  */
 declare function startProdServer(options?: ProdServerOptions): Promise<{
-  server: _$node_http0.Server<typeof IncomingMessage, typeof ServerResponse>;
+  server: import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;
   port: number;
 }>;
 type AppRouterPrerenderSeeder = (serverDir: string) => Promise<number>;
@@ -102,5 +105,4 @@ declare function resolveAppRouterPrerenderSeeder(entryModule: unknown): AppRoute
  */
 declare function resolveAppRouterAssetPath(pathname: string, assetPathPrefix: string, assetPrefix: string): string | null;
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, ProdServerOptions, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
-//# sourceMappingURL=prod-server.d.ts.map
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, ProdServerOptions, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };

package/dist/server/prod-server.js

@@ -2,11 +2,9 @@ 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";
@@ -14,10 +12,13 @@ import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, resol
 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 { mergeHeaders } from "./worker-utils.js";
+import { runPagesRequest } from "./pages-request-pipeline.js";
 import { manifestFileWithBase } from "../utils/manifest-paths.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 { findClientEntryFile, findPagesClientEntryFile, readClientBuildManifest } from "../utils/client-build-manifest.js";
+import { findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest } from "../utils/client-entry-manifest.js";
 import { readPrerenderSecret } from "../build/server-manifest.js";
 import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
 import fs from "node:fs";
@@ -157,10 +158,6 @@ 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 filtered = {};
@@ -175,10 +172,6 @@ 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 isNoBodyResponseStatus(status) {
 	return NO_BODY_RESPONSE_STATUSES.has(status);
 }
@@ -201,36 +194,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
@@ -624,6 +596,44 @@ 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 buildManifest = readClientBuildManifest(path.join(options.clientDir, ".vite", "manifest.json"));
+	const clientEntryManifest = readClientEntryManifest(options.clientDir);
+	const entryOptions = {
+		clientDir: options.clientDir,
+		assetsSubdir: options.assetsSubdir,
+		assetBase: options.assetBase,
+		...buildManifest ? { buildManifest } : {}
+	};
+	globalThis.__VINEXT_CLIENT_ENTRY__ = options.clientEntryLookup === "pages-client-entry" ? findPagesClientEntryFileFromVinextManifest(clientEntryManifest, options.assetBase) ?? findPagesClientEntryFile(entryOptions) : findClientEntryFileFromVinextManifest(clientEntryManifest, options.assetBase) ?? findClientEntryFile(entryOptions);
+	if (buildManifest) {
+		const lazyChunks = computeLazyChunks(buildManifest).map((file) => manifestFileWithBase(file, options.assetBase));
+		globalThis.__VINEXT_LAZY_CHUNKS__ = lazyChunks.length > 0 ? lazyChunks : void 0;
+	} else globalThis.__VINEXT_LAZY_CHUNKS__ = void 0;
+	return ssrManifest;
+}
 /**
 * Start the App Router production server.
 *
@@ -653,9 +663,18 @@ async function startAppRouterServer(options) {
 	const rscModule = await import(`${pathToFileURL(rscEntryPath).href}?t=${rscMtime}`);
 	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,
+		assetsSubdir: resolveAssetsDir(appRouterAssetPrefix),
+		assetBase: appAssetBase,
+		clientEntryLookup: "pages-client-entry"
+	});
 	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);
@@ -811,20 +830,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
+		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 +926,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 +945,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" ? runMiddleware : 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) {
@@ -1135,5 +1019,3 @@ 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 };
-
-//# sourceMappingURL=prod-server.js.map

package/dist/server/proxy-trust.d.ts

@@ -37,5 +37,4 @@ declare function resolveRequestProtocol(source: IncomingMessage | Headers): "htt
  */
 declare function resolveRequestHost(source: IncomingMessage | Headers, fallback: string): string;
 //#endregion
-export { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts };
-//# sourceMappingURL=proxy-trust.d.ts.map
+export { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts };

package/dist/server/proxy-trust.js

@@ -66,5 +66,3 @@ function isWebHeaders(source) {
 }
 //#endregion
 export { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts };
-
-//# sourceMappingURL=proxy-trust.js.map

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

@@ -36,5 +36,4 @@ declare function logRequest({
  */
 declare function now(): number;
 //#endregion
-export { logRequest, now };
-//# sourceMappingURL=request-log.d.ts.map
+export { logRequest, now };

package/dist/server/request-log.js

@@ -54,5 +54,3 @@ function now() {
 }
 //#endregion
 export { logRequest, now };
-
-//# sourceMappingURL=request-log.js.map

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

@@ -205,6 +205,18 @@ declare function filterInternalHeaders(headers: Headers): Headers;
  * a RequestInit with best-effort metadata.
  */
 declare function cloneRequestWithHeaders(request: Request, headers: Headers): Request;
+/**
+ * Clone a Request while overriding the URL, preserving headers and metadata
+ * when possible.
+ *
+ * Mirrors `cloneRequestWithHeaders`, but rewrites the URL instead of the
+ * headers. Workers support `new Request(url, request)` to copy method/headers/
+ * body onto a new URL; Node/undici can throw on a foreign Request instance, so
+ * we fall back to a manual RequestInit. `new Request()` does not copy the
+ * Workers-specific `cf` property and omits `duplex` for streaming bodies, so
+ * both are handled explicitly — the same reasons `cloneRequestWithHeaders`
+ * exists.
+ */
+declare function cloneRequestWithUrl(request: Request, url: string): Request;
 //#endregion
-export { HeaderRecord, INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, applyConfigHeadersToHeaderRecord, applyConfigHeadersToResponse, cloneRequestWithHeaders, createStaticFileSignal, filterInternalHeaders, guardProtocolRelativeUrl, hasBasePath, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, stripBasePath, validateCsrfOrigin, validateImageUrl, validateServerActionPayload };
-//# sourceMappingURL=request-pipeline.d.ts.map
+export { HeaderRecord, INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, applyConfigHeadersToHeaderRecord, applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, filterInternalHeaders, guardProtocolRelativeUrl, hasBasePath, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, stripBasePath, validateCsrfOrigin, validateImageUrl, validateServerActionPayload };

package/dist/server/request-pipeline.js

@@ -423,7 +423,46 @@ function cloneRequestWithHeaders(request, headers) {
 	});
 	return cloned;
 }
+/**
+* Clone a Request while overriding the URL, preserving headers and metadata
+* when possible.
+*
+* Mirrors `cloneRequestWithHeaders`, but rewrites the URL instead of the
+* headers. Workers support `new Request(url, request)` to copy method/headers/
+* body onto a new URL; Node/undici can throw on a foreign Request instance, so
+* we fall back to a manual RequestInit. `new Request()` does not copy the
+* Workers-specific `cf` property and omits `duplex` for streaming bodies, so
+* both are handled explicitly — the same reasons `cloneRequestWithHeaders`
+* exists.
+*/
+function cloneRequestWithUrl(request, url) {
+	let cloned;
+	try {
+		cloned = new Request(url, request);
+	} catch {
+		const init = {
+			method: request.method,
+			headers: request.headers,
+			body: request.body ?? void 0,
+			redirect: request.redirect,
+			signal: request.signal,
+			integrity: request.integrity,
+			cache: request.cache,
+			mode: request.mode,
+			credentials: request.credentials,
+			referrer: request.referrer,
+			referrerPolicy: request.referrerPolicy
+		};
+		if (request.body) init.duplex = "half";
+		cloned = new Request(url, init);
+	}
+	const cf = getRequestCf(request);
+	if (cf !== void 0) Object.defineProperty(cloned, "cf", {
+		value: cf,
+		enumerable: true,
+		configurable: true
+	});
+	return cloned;
+}
 //#endregion
-export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, applyConfigHeadersToHeaderRecord, applyConfigHeadersToResponse, cloneRequestWithHeaders, createStaticFileSignal, filterInternalHeaders, guardProtocolRelativeUrl, hasBasePath, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, stripBasePath, validateCsrfOrigin, validateImageUrl, validateServerActionPayload };
-
-//# sourceMappingURL=request-pipeline.js.map
+export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, applyConfigHeadersToHeaderRecord, applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, filterInternalHeaders, guardProtocolRelativeUrl, hasBasePath, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, stripBasePath, validateCsrfOrigin, validateImageUrl, validateServerActionPayload };

package/dist/server/rsc-stream-hints.d.ts

@@ -3,5 +3,4 @@ declare function normalizeReactFlightPreloadHints(stream: ReadableStream<Uint8Ar
 type RscRawRenderer = (model: unknown, options?: unknown) => ReadableStream<Uint8Array>;
 declare function createRscRenderer(render: RscRawRenderer): RscRawRenderer;
 //#endregion
-export { createRscRenderer, normalizeReactFlightPreloadHints };
-//# sourceMappingURL=rsc-stream-hints.d.ts.map
+export { createRscRenderer, normalizeReactFlightPreloadHints };