vinext 1.2.1 → 1.3.1

package/dist/server/pages-request-stage-entry.js

@@ -7,7 +7,7 @@ import { attachRequestCfMetadata, cloneRequestWithHeaders, cloneRequestWithUrl,
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { normalizeDefaultLocalePathname, shouldRestoreLocaleRootTrailingSlash } from "./pages-i18n.js";
 import { isNextDataPathname } from "./pages-data-route.js";
 import { getExplicitCdnCacheAdapter } from "../shims/cdn-cache-state.js";
 import { CACHEABILITY_REQUEST_STATE } from "../shims/cacheability-classification.js";
@@ -48,6 +48,10 @@ const pagesRequestStagePrerenderSecret = pagesEntry.prerenderSecret ?? null;
 const basePath = vinextConfig?.basePath ?? "";
 const assetPathPrefix = assetPrefixPathname(vinextConfig?.assetPrefix ?? "");
 const trailingSlash = vinextConfig?.trailingSlash ?? false;
+const localeRootTrailingSlashConfig = {
+	trailingSlash,
+	skipProxyUrlNormalize: vinextConfig?.skipProxyUrlNormalize
+};
 const skipTrailingSlashRedirect = vinextConfig?.skipTrailingSlashRedirect ?? false;
 const i18nConfig = vinextConfig?.i18n ?? null;
 const configRedirects = vinextConfig?.redirects ?? [];
@@ -88,7 +92,7 @@ function handleRequestStageLocally(request, env, ctx, dispatchResponseStage) {
 function handleRequest(request, env, platformCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets) {
 	const url = new URL(request.url);
 	const trace = async () => {
-		await pagesEntry.__ensureInstrumentation?.();
+		await pagesEntry.__ensureInstrumentation?.(platformCtx);
 		return traceFrameworkRequest({
 			callback: () => handleRequestImpl(request, env, platformCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets),
 			getStatus: (response) => response?.status,
@@ -175,6 +179,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 		}
 		const missingBuildAsset = isNextStaticPath(pathname, basePath, assetPathPrefix);
 		const hadBasePath = !basePath || hasBasePath(pathname, basePath);
+		const restoreLocaleRootTrailingSlash = shouldRestoreLocaleRootTrailingSlash(pathname, localeRootTrailingSlashConfig);
 		{
 			const stripped = stripBasePath(pathname, basePath);
 			if (stripped !== pathname) {
@@ -193,7 +198,10 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			request = dataNorm.request;
 			pathname = dataNorm.normalizedPathname;
 		}
-		const responseStagePolicyPathname = i18nConfig ? normalizeDefaultLocalePathname(pathname, i18nConfig, { hostname: url.hostname }) : pathname;
+		const responseStagePolicyPathname = i18nConfig ? normalizeDefaultLocalePathname(pathname, i18nConfig, {
+			hostname: url.hostname,
+			restoreRootTrailingSlash: restoreLocaleRootTrailingSlash
+		}) : pathname;
 		const responseStagePolicyHeaders = resolveResponseStageCachePolicy({
 			basePathState: {
 				basePath,
@@ -219,6 +227,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			hasMiddleware,
 			ctx,
 			recordCacheability: forceCacheBypass,
+			restoreLocaleRootTrailingSlash,
 			middlewareRequest: isDataReq && vinextConfig?.skipProxyUrlNormalize ? middlewareRequest : void 0,
 			dataNotFoundResponse: vinextConfig?.skipProxyUrlNormalize ? dataNorm.notFoundResponse : null,
 			authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
@@ -320,7 +329,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						fetchPublicFile: (sourceRequest) => resolvePublicImageSource(sourceRequest, assets)
 					}), allowedWidths, imageConfig);
 				}
-				return fetchWorkerFilesystemRoute(filesystemRequest, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, hadBasePath);
+				return fetchWorkerFilesystemRoute(filesystemRequest, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, resolvedPathnameHasBasePath);
 			}
 		};
 		const resolvePublicImageSource = async (sourceRequest, sourceAssets) => {
@@ -333,6 +342,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			const sourceResult = await runPagesRequest(attachRequestCfMetadata(new Request(new URL(sourcePathname + sourceUrl.search, sourceUrl), { signal: sourceRequest.signal }), sourceRequest), {
 				...deps,
 				hadBasePath: sourceHadBasePath,
+				restoreLocaleRootTrailingSlash: shouldRestoreLocaleRootTrailingSlash(sourceUrl.pathname, localeRootTrailingSlashConfig),
 				isDataReq: false,
 				isDataRequest: false,
 				middlewareRequest: void 0,
@@ -341,9 +351,9 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 				runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, sourceHadBasePath) : null,
 				renderPage: null,
 				handleApi: null,
-				serveFilesystemRoute: async (candidate, _stagedHeaders, phase, _resolvedUrl, filesystemRequest) => {
+				serveFilesystemRoute: async (candidate, _stagedHeaders, phase, _resolvedUrl, filesystemRequest, candidateHasBasePath) => {
 					if (isImageOptimizationPath(candidate)) return false;
-					const asset = await fetchWorkerFilesystemRoute(filesystemRequest, candidate, phase, (assetRequest) => Promise.resolve(sourceAssets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, sourceHadBasePath);
+					const asset = await fetchWorkerFilesystemRoute(filesystemRequest, candidate, phase, (assetRequest) => Promise.resolve(sourceAssets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, candidateHasBasePath);
 					if (asset === false) return false;
 					sourceAsset = asset;
 					return new Response(null);

package/dist/server/pages-response-stage-entry.d.ts

@@ -8,4 +8,5 @@ type PagesWorkerExecutionContext = ExecutionContextLike & {
 };
 export declare function renderPagesResponse(request: Request, env: PagesWorkerEnv | undefined, platformCtx: PagesWorkerExecutionContext | undefined, props: WorkerResponseStageProps, stagedHeaders?: Headers, dispatchRequestStage?: VinextRequestStageTransport, dispatchOptions?: VinextResponseStageDispatchOptions): Promise<Response>;
 export declare function handleResponseStage(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined, props: WorkerResponseStageProps, dispatchRequestStage: VinextRequestStageTransport, options: VinextResponseStageDispatchOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-response-stage-entry.js

@@ -36,7 +36,7 @@ async function renderPagesResponse(request, env, platformCtx, props, stagedHeade
 	if (!isPagesResponseStageProps(props)) return new Response("Invalid vinext Pages response stage", { status: 400 });
 	if (props.buildId !== pagesEntry.buildId) return new Response("Vinext Pages response stage deployment mismatch", { status: 409 });
 	if (props.requestHost !== new URL(request.url).host) return new Response("Invalid vinext Pages response stage", { status: 400 });
-	await pagesEntry.__ensureInstrumentation?.();
+	await pagesEntry.__ensureInstrumentation?.(platformCtx);
 	registerConfiguredImageOptimizer(env);
 	const renderHeaders = new Headers(stagedHeaders ?? props.stagedHeaders ?? []);
 	renderHeaders.delete("Content-Length");

package/dist/server/pages-revalidate.js

@@ -12,6 +12,7 @@ async function performOnDemandRevalidate(source, urlPath, opts = {}, trustedOrig
 	if (isSourceRevalidationRequest(source)) throw new Error(`Cannot revalidate ${urlPath} from an internal revalidation request`);
 	const executionContext = getRequestExecutionContext();
 	const dispatchRevalidate = executionContext?.dispatchPagesRevalidate;
+	if (!dispatchRevalidate && !trustedOrigin) throw new Error(`Cannot revalidate ${urlPath}: no in-process dispatcher or server-owned origin is available`);
 	const target = createRevalidateTarget(source, urlPath, trustedOrigin);
 	const headers = { [PRERENDER_REVALIDATE_HEADER]: getRevalidateSecret() };
 	if (trustedOrigin && !dispatchRevalidate) {

package/dist/server/pages-route-data-kind.d.ts

@@ -15,4 +15,5 @@ type AppComponent = {
 } | null;
 /** Classify loaded Pages modules after HOCs and re-exports have been evaluated. */
 export declare function getRuntimePagesDataKind(pageModule: PagesModule, appComponent: AppComponent): RuntimePagesDataKind;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-router-entry.js

@@ -20,7 +20,7 @@ async function handleSingleStageRequest(request, env, platformCtx) {
 	let ctx = createWorkerPrerenderDiscoveryContext(ctxWithRevalidation, request, pagesRequestStagePrerenderSecret);
 	const readinessResponse = createWorkerPrerenderReadinessResponse(ctx, request);
 	if (readinessResponse) {
-		if (readinessResponse.status === 204) await Promise.all([__ensureInstrumentation(), __ensureInstrumentation$1()]);
+		if (readinessResponse.status === 204) await Promise.all([__ensureInstrumentation(ctx), __ensureInstrumentation$1(ctx)]);
 		return await validateCdnRequest(request) ?? readinessResponse;
 	}
 	const isClientBuildFile = isPagesClientBuildFileRequest(request, env, ctx);

package/dist/server/prerender-cache-life-header.d.ts

@@ -7,4 +7,5 @@ type PrerenderCacheLife = {
 };
 export declare function applyPrerenderCacheLifeHeader(headers: Headers, requestCacheLife: PrerenderCacheLife | null | undefined): void;
 export declare function applyPrerenderCacheTagsHeader(headers: Headers, cacheTags: readonly string[]): void;
-//#endregion
+//#endregion
+export {};

package/dist/server/prerender-route-params.d.ts

@@ -26,4 +26,5 @@ export declare function readTrustedPrerenderStateFromHeaders(headers: Headers, e
 export declare function readTrustedPrerenderRouteParams(request: Request): PrerenderRouteParamsPayload | null;
 export declare function matchPrerenderRouteParamsPayload(payload: PrerenderRouteParamsPayload | null, routePattern: string, params: PrerenderRouteParams): PrerenderRouteParamsRouteMatch | null;
 export declare function encodePrerenderRouteParams(pattern: string, params: PrerenderRouteParams, fallbackParamNames?: readonly string[]): PrerenderRouteParamsPayload | null;
-//#endregion
+//#endregion
+export {};

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

@@ -3,7 +3,7 @@ import { negotiateEncoding } from "./accept-encoding.js";
 import { StaticFileCache } from "./static-file-cache.js";
 import { resolveRequestHost, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { COMPRESS_THRESHOLD, isCompressibleContentType } from "./response-compression.js";
-import { IncomingMessage, ServerResponse } from "node:http";
+import { IncomingMessage, Server, ServerResponse } from "node:http";
 //#region src/server/prod-server.d.ts
 /**
  * Import a built server entry module (App Router RSC entry or Pages Router
@@ -127,7 +127,7 @@ declare function waitForNodeResponseCompletion(res: ServerResponse): Promise<voi
  * Pages Router (dist/server/entry.js) and configures the appropriate handler.
  */
 export declare function startProdServer(options?: ProdServerOptions): Promise<{
-  server: import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;
+  server: Server<typeof IncomingMessage, typeof ServerResponse>;
   port: number;
 }>;
 type AppRouterPrerenderSeeder = (serverDir: string) => Promise<number>;

package/dist/server/prod-server.js

@@ -7,11 +7,12 @@ import { notFoundResponse } from "./http-error-responses.js";
 import { getRepeatedSlashRedirect, isOpenRedirectShaped, sendRepeatedSlashRedirect } from "./open-redirect.js";
 import { readStaticFileSignal } from "./static-file-signal.js";
 import { canonicalizeRequestPathname, filterInternalHeaders } from "./request-pipeline.js";
-import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from "../utils/asset-prefix.js";
+import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isAssetPrefixBuildAsset } from "../utils/asset-prefix.js";
 import { StaticFileCache, contentTypeForPath, etagFromFilenameHash } from "./static-file-cache.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
-import { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts } from "./proxy-trust.js";
+import { resolveRequestHost, resolveRequestProtocol, resolveTrustedForwardedHost, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { normalizePath } from "./normalize-path.js";
+import { shouldRestoreLocaleRootTrailingSlash } from "./pages-i18n.js";
 import { buildNextDataNotFoundResponse, encodeUrlParserIgnoredCharacters, isNextDataPathname, normalizeNextDataPagePathname, parseNextDataPathname, shouldAddTrailingSlashToPagesDataPath, urlParserCreatesPagesDataPath } from "./pages-data-route.js";
 import { buildCacheStateHeaders } from "./cache-headers.js";
 import { parseHttpDate } from "./http-date.js";
@@ -30,7 +31,6 @@ import { readPrerenderSecret, readServerCompress } from "../build/server-manifes
 import { readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { resolveClientBuildFile } from "./client-build-files.js";
 import { registerPrerenderCloudflareLoader } from "../build/prerender-cloudflare-loader.js";
-import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
 import { negotiateEncoding, parseAcceptedEncodings, selectContentEncoding } from "./accept-encoding.js";
 import { COMPRESS_THRESHOLD, hasNoTransform, isCompressibleContentType, parseContentLengthHeader, resolveResponseCompression } from "./response-compression.js";
 import { ifRangeAllowsRange, parseByteRange } from "./http-range.js";
@@ -328,6 +328,7 @@ function installClientBuildManifestGlobals(clientDir, assetBase, assetPrefix, cr
 	});
 	setPagesClientAssets({
 		appBootstrapPreinitModules: metadata.appBootstrapPreinitModules,
+		appRouteManifestModule: metadata.appRouteManifestModule,
 		lazyChunks: metadata.lazyChunks,
 		dynamicPreloads: metadata.dynamicPreloads,
 		crossOrigin
@@ -378,6 +379,19 @@ function isVinextStreamedHtmlResponse(response) {
 function isVinextStreamedApiResponse(response) {
 	return response.__vinextStreamedApiResponse === true;
 }
+function disablePrerenderKeepAliveTimeout(server, purpose) {
+	if (purpose === "prerender") server.keepAliveTimeout = 0;
+}
+function listen(server, port, host) {
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, host, () => {
+			server.off("error", reject);
+			const addr = server.address();
+			resolve(typeof addr === "object" && addr ? addr.port : port);
+		});
+	});
+}
 function logProdServerStarted(host, port, purpose) {
 	const url = `http://${host}:${port}`;
 	if (purpose === "prerender") {
@@ -890,6 +904,7 @@ function waitForNodeResponseCompletion(res) {
 */
 async function startProdServer(options = {}) {
 	installSocketErrorBackstop({ runningServer: options.purpose !== "prerender" });
+	if (options.purpose !== "prerender" && !process.env.NODE_ENV) Reflect.set(process.env, "NODE_ENV", "production");
 	const { port = process.env.PORT ? parseInt(process.env.PORT) : 3e3, host = "0.0.0.0", outDir = path.resolve("dist"), rscEntryPath: explicitRscEntryPath, serverDir: explicitServerDir, serverEntryPath: explicitServerEntryPath, noCompression = false, purpose, silent = false } = options;
 	if (purpose === "prerender") registerPrerenderCloudflareLoader();
 	const compress = !noCompression;
@@ -925,14 +940,16 @@ async function startProdServer(options = {}) {
 		silent
 	});
 }
-function createNodeExecutionContext(trustedRevalidateOrigin) {
+function createNodeExecutionContext(trustedRevalidateOrigin, { middlewareOrigin, requestSignal } = {}) {
 	return {
 		hostRuntime: "node",
+		requestSignal,
 		waitUntil(promise) {
 			Promise.resolve(promise).catch(() => {});
 		},
 		passThroughOnException() {},
-		trustedRevalidateOrigin
+		trustedRevalidateOrigin,
+		middlewareOrigin
 	};
 }
 /**
@@ -953,8 +970,26 @@ function markPrerenderSpecialError(response, marker) {
 	});
 }
 function resolveTrustedNodeRevalidateOrigin(req, configuredHost, configuredPort) {
+	return `http://${resolveNodeServerHost(req, configuredHost, configuredPort)}`;
+}
+/**
+* The origin middleware runs against. The Host header is client-controlled,
+* so, like Next.js, which builds the middleware URL from its own hostname and
+* port, it never counts as the server's origin. Otherwise a client could send
+* the host of an external middleware rewrite target and turn that rewrite into
+* an internal one, skipping middleware's checks for the target path. A trusted
+* `X-Forwarded-Host` is operator-approved, so it keeps the request origin, and
+* rewrites to that host stay internal.
+*/
+function resolveNodeMiddlewareOrigin(req, requestUrl, configuredHost, configuredPort) {
+	const url = new URL(requestUrl);
+	if (resolveTrustedForwardedHost(req) !== void 0) return url.origin;
+	return `${url.protocol}//${resolveNodeServerHost(req, configuredHost, configuredPort)}`;
+}
+/** The `host:port` this server is reachable at locally. */
+function resolveNodeServerHost(req, configuredHost, configuredPort) {
 	const port = req.socket.localPort ?? configuredPort;
-	return `http://${normalizeInternalFetchHost(configuredHost)}:${port}`;
+	return `${normalizeInternalFetchHost(configuredHost)}:${port}`;
 }
 function normalizeInternalFetchHost(host) {
 	if (!host || host === "0.0.0.0" || host === "::") return "localhost";
@@ -973,15 +1008,19 @@ 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);
 }
+async function seedMemoryCacheFromPrerenderFallback(serverDir) {
+	const { seedMemoryCacheFromPrerender } = await import("./seed-cache.js");
+	return seedMemoryCacheFromPrerender(serverDir);
+}
 function isAppRouterPrerenderSeederExport(value) {
 	return typeof value === "function";
 }
 function resolveAppRouterPrerenderSeeder(entryModule) {
-	if (typeof entryModule !== "object" || entryModule === null) return seedMemoryCacheFromPrerender;
+	if (typeof entryModule !== "object" || entryModule === null) return seedMemoryCacheFromPrerenderFallback;
 	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;
+		return seedMemoryCacheFromPrerenderFallback;
 	}
 	if (process.env.NEXT_PRIVATE_DEBUG_CACHE) console.debug("[vinext] ISR: using App Router entry prerender cache seeder");
 	return async (serverDir) => {
@@ -1057,7 +1096,9 @@ function installPagesClientAssets(options) {
 	setPagesClientAssets({
 		clientEntry: metadata.clientEntryFile,
 		appBootstrapPreinitModules: metadata.appBootstrapPreinitModules,
+		appRouteManifestModule: metadata.appRouteManifestModule,
 		ssrManifest: Object.keys(ssrManifest).length > 0 ? ssrManifest : void 0,
+		sharedChunks: metadata.sharedChunks,
 		cssGraph: metadata.cssGraph,
 		lazyChunks: metadata.lazyChunks,
 		dynamicPreloads: metadata.dynamicPreloads,
@@ -1154,7 +1195,7 @@ async function startAppRouterServer(options) {
 		const assetLookupPath = sourcePathname !== null ? resolveAppRouterAssetPath(sourcePathname, appAssetPathPrefix, appRouterAssetPrefix) : null;
 		if (assetLookupPath && await serveSource(assetLookupPath)) return;
 		if (sourcePathname !== null) {
-			const sourceResponse = await rscHandler(new Request(sourceUrl, { signal: request.signal }), createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port)));
+			const sourceResponse = await rscHandler(new Request(sourceUrl, { signal: request.signal }), createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port), { middlewareOrigin: resolveNodeMiddlewareOrigin(req, request.url, host, port) }));
 			const sourceSignal = isImageSourceBodyStatus(sourceResponse.status) ? readStaticFileSignal(sourceResponse) : null;
 			cancelResponseBody(sourceResponse, request.signal.reason);
 			if (request.signal.aborted) return;
@@ -1211,8 +1252,12 @@ async function startAppRouterServer(options) {
 			if (clientBuildFile && await tryServeStatic(req, res, clientDir, clientBuildFile, compress, staticCache)) return;
 		}
 		try {
-			const request = nodeToWebRequest(req, rawUrl, prerenderSecret, appRouterI18nConfig, appRouterAuthorizeOnDemandRevalidate, signalFromNodeResponse(res));
-			const ctx = createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port));
+			const signal = signalFromNodeResponse(res);
+			const request = nodeToWebRequest(req, rawUrl, prerenderSecret, appRouterI18nConfig, appRouterAuthorizeOnDemandRevalidate, signal);
+			const ctx = createNodeExecutionContext(resolveTrustedNodeRevalidateOrigin(req, host, port), {
+				middlewareOrigin: resolveNodeMiddlewareOrigin(req, request.url, host, port),
+				requestSignal: signal
+			});
 			const recorded = {};
 			if (purpose === "prerender") ctx.recordPrerenderSpecialError = (marker) => {
 				recorded.marker = marker;
@@ -1282,18 +1327,12 @@ async function startAppRouterServer(options) {
 	const server = createServer((req, res) => {
 		runWithServerEntryRequire(rscEntryRequire, () => handleRequest(req, res));
 	});
-	await new Promise((resolve) => {
-		server.listen(port, host, () => {
-			const addr = server.address();
-			const actualPort = typeof addr === "object" && addr ? addr.port : port;
-			if (!silent) logProdServerStarted(host, actualPort, purpose);
-			resolve();
-		});
-	});
-	const addr = server.address();
+	disablePrerenderKeepAliveTimeout(server, purpose);
+	const actualPort = await listen(server, port, host);
+	if (!silent) logProdServerStarted(host, actualPort, purpose);
 	return {
 		server,
-		port: typeof addr === "object" && addr ? addr.port : port
+		port: actualPort
 	};
 }
 function isPagesServerEntryPageRoute(value) {
@@ -1323,18 +1362,12 @@ async function startPagesRouterServer(options) {
 	const { port, host, purpose, silent } = options;
 	const handler = await createPagesRouterRequestHandler(options);
 	const server = createServer(handler);
-	await new Promise((resolve) => {
-		server.listen(port, host, () => {
-			const addr = server.address();
-			const actualPort = typeof addr === "object" && addr ? addr.port : port;
-			if (!silent) logProdServerStarted(host, actualPort, purpose);
-			resolve();
-		});
-	});
-	const addr = server.address();
+	disablePrerenderKeepAliveTimeout(server, purpose);
+	const actualPort = await listen(server, port, host);
+	if (!silent) logProdServerStarted(host, actualPort, purpose);
 	return {
 		server,
-		port: typeof addr === "object" && addr ? addr.port : port
+		port: actualPort
 	};
 }
 /**
@@ -1481,6 +1514,10 @@ async function createPagesRouterRequestHandler(options) {
 		}
 		try {
 			const hadBasePath = !basePath || hasBasePath(requestPathname, basePath);
+			const restoreLocaleRootTrailingSlash = shouldRestoreLocaleRootTrailingSlash(requestPathname, {
+				trailingSlash,
+				skipProxyUrlNormalize
+			});
 			let configMatchPathname = stripBasePath(requestPathname, basePath);
 			{
 				const strippedPathname = stripBasePath(pathname, basePath);
@@ -1543,6 +1580,8 @@ async function createPagesRouterRequestHandler(options) {
 				duplex: hasBody ? "half" : void 0
 			});
 			const middlewareRequest = isDataReq && skipProxyUrlNormalize ? new Request(new URL(originalRenderUrl, webRequest.url), webRequest) : void 0;
+			const middlewareCtx = createNodeExecutionContext(void 0, { middlewareOrigin: resolveNodeMiddlewareOrigin(req, webRequest.url, host, port) });
+			const runNodeMiddleware = typeof runMiddleware === "function" ? (request, _ctx, opts) => runMiddleware(request, middlewareCtx, opts) : null;
 			const resolvePublicImageSource = async (sourceUrl) => {
 				const rawSourcePathname = sourceUrl.pathname;
 				if (getRepeatedSlashRedirect(rawSourcePathname) || isOpenRedirectShaped(rawSourcePathname)) return null;
@@ -1561,11 +1600,15 @@ async function createPagesRouterRequestHandler(options) {
 					recordCacheability: false,
 					rawSearch: sourceUrl.search,
 					configMatchPathname: strippedSourcePathname,
-					runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, sourceHadBasePath) : null,
+					restoreLocaleRootTrailingSlash: shouldRestoreLocaleRootTrailingSlash(sourceRequestPathname, {
+						trailingSlash,
+						skipProxyUrlNormalize
+					}),
+					runMiddleware: runNodeMiddleware ? wrapMiddlewareWithBasePath(runNodeMiddleware, basePath, sourceHadBasePath) : null,
 					renderPage: null,
 					handleApi: null,
-					serveFilesystemRoute: async (candidate, _stagedHeaders, phase) => {
-						if (isImageOptimizationPath(candidate) || isPagesFilesystemExcludedPath(candidate, phase)) return false;
+					serveFilesystemRoute: async (candidate, _stagedHeaders, phase, _resolvedUrl, _request, candidateHasBasePath) => {
+						if (!candidateHasBasePath && !isAssetPrefixBuildAsset(candidate, pagesAssetPathPrefix) || isImageOptimizationPath(candidate) || isPagesFilesystemExcludedPath(candidate, phase)) return false;
 						const lookupPath = staticCacheLookupPath(candidate);
 						if (lookupPath === null || lookupPath === "/" || !staticCache.lookup(lookupPath)) return false;
 						sourcePath = candidate;
@@ -1595,9 +1638,10 @@ async function createPagesRouterRequestHandler(options) {
 				rawSearch: rawQs,
 				authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
 				configMatchPathname,
+				restoreLocaleRootTrailingSlash,
 				matchPageRoute: matchPageRoute ?? null,
 				matchApiRoute: matchApiRoute ?? null,
-				runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) : null,
+				runMiddleware: runNodeMiddleware ? wrapMiddlewareWithBasePath(runNodeMiddleware, basePath, hadBasePath) : null,
 				renderPage: typeof renderPage === "function" ? (request, resolvedUrl, options, stagedHeaders) => renderPage(request, resolvedUrl, ssrManifest, void 0, stagedHeaders, {
 					...options,
 					originalUrl: originalRenderUrl
@@ -1648,7 +1692,7 @@ async function createPagesRouterRequestHandler(options) {
 						res.end(INVALID_IMAGE_SOURCE_MESSAGE);
 						return true;
 					}
-					if (isPagesFilesystemExcludedPath(requestPathname, phase)) return false;
+					if (!resolvedPathnameHasBasePath && !isAssetPrefixBuildAsset(requestPathname, pagesAssetPathPrefix) || isPagesFilesystemExcludedPath(requestPathname, phase)) return false;
 					return tryServeStatic(req, res, clientDir, requestPathname, compress, staticCache, stagedHeaders);
 				}
 			};

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

@@ -35,4 +35,10 @@ export declare function resolveRequestProtocol(source: IncomingMessage | Headers
  * against `request.url`.
  */
 export declare function resolveRequestHost(source: IncomingMessage | Headers, fallback: string): string;
+/**
+ * The `X-Forwarded-Host` value when it matches the `trustedHosts` allow-list,
+ * otherwise undefined. Unlike the raw `Host` header, this host is
+ * operator-approved.
+ */
+export declare function resolveTrustedForwardedHost(source: IncomingMessage | Headers): string | undefined;
 //#endregion

package/dist/server/proxy-trust.js

@@ -42,12 +42,18 @@ function resolveRequestProtocol(source) {
 * against `request.url`.
 */
 function resolveRequestHost(source, fallback) {
+	return resolveTrustedForwardedHost(source) ?? (readHost(source) || fallback);
+}
+/**
+* The `X-Forwarded-Host` value when it matches the `trustedHosts` allow-list,
+* otherwise undefined. Unlike the raw `Host` header, this host is
+* operator-approved.
+*/
+function resolveTrustedForwardedHost(source) {
 	const rawForwarded = readForwardedHost(source);
-	if (rawForwarded && trustedHosts.size > 0) {
-		const forwardedHost = rawForwarded.split(",")[0]?.trim().toLowerCase();
-		if (forwardedHost && trustedHosts.has(forwardedHost)) return forwardedHost;
-	}
-	return readHost(source) || fallback;
+	if (!rawForwarded || trustedHosts.size === 0) return void 0;
+	const forwardedHost = rawForwarded.split(",")[0]?.trim().toLowerCase();
+	return forwardedHost && trustedHosts.has(forwardedHost) ? forwardedHost : void 0;
 }
 function readForwardedProto(source) {
 	if (isWebHeaders(source)) return source.get("x-forwarded-proto") ?? void 0;
@@ -65,4 +71,4 @@ function isWebHeaders(source) {
 	return typeof source.get === "function";
 }
 //#endregion
-export { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts };
+export { resolveRequestHost, resolveRequestProtocol, resolveTrustedForwardedHost, trustProxy, trustedHosts };

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

@@ -31,4 +31,5 @@ export declare function logRequest({ method, url, status, totalMs, compileMs, re
  * Returns `performance.now()` - a high-resolution monotonic timestamp.
  */
 export declare function now(): number;
-//#endregion
+//#endregion
+export {};

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

@@ -143,6 +143,11 @@ export declare function isOriginAllowed(origin: string, allowed: string[]): bool
  *
  * @param headers - The Headers object to modify in place
  */
+/**
+ * Next.js drops each empty middleware Set-Cookie value when it converts
+ * middleware's response headers, so blank values never reach the response.
+ */
+export declare function dropEmptyMiddlewareSetCookie(headers: Headers): void;
 export declare function processMiddlewareHeaders(headers: Headers): void;
 /**
  * Strip internal headers from an inbound request so they cannot be forged by

package/dist/server/request-pipeline.js

@@ -313,7 +313,18 @@ function isOriginAllowed(origin, allowed) {
 *
 * @param headers - The Headers object to modify in place
 */
+/**
+* Next.js drops each empty middleware Set-Cookie value when it converts
+* middleware's response headers, so blank values never reach the response.
+*/
+function dropEmptyMiddlewareSetCookie(headers) {
+	const cookies = headers.getSetCookie();
+	if (!cookies.includes("")) return;
+	headers.delete("set-cookie");
+	for (const cookie of cookies) if (cookie) headers.append("set-cookie", cookie);
+}
 function processMiddlewareHeaders(headers) {
+	dropEmptyMiddlewareSetCookie(headers);
 	const keysToDelete = [];
 	const unconsumedRequestHeaders = getUnconsumedMiddlewareRequestHeaders(headers);
 	for (const key of headers.keys()) if (key.startsWith("x-middleware-") && key !== "x-middleware-cache" && !unconsumedRequestHeaders.has(key)) keysToDelete.push(key);
@@ -433,4 +444,4 @@ function cloneRequestWithUrl(request, url) {
 	return attachRequestCfMetadata(cloned, request);
 }
 //#endregion
-export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, attachRequestCfMetadata, canonicalizeRequestPathname, canonicalizeRequestUrlPathname, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, filterInternalHeaders, getRepeatedSlashRedirect, guardProtocolRelativeUrl, hasBasePath, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, sendRepeatedSlashRedirect, stripBasePath, validateCsrfOrigin, validateServerActionPayload };
+export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, attachRequestCfMetadata, canonicalizeRequestPathname, canonicalizeRequestUrlPathname, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, dropEmptyMiddlewareSetCookie, filterInternalHeaders, getRepeatedSlashRedirect, guardProtocolRelativeUrl, hasBasePath, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, sendRepeatedSlashRedirect, stripBasePath, validateCsrfOrigin, validateServerActionPayload };

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

@@ -19,4 +19,5 @@ export declare function clearFrameworkRequestError(response: Response): Response
 export declare function attachFrameworkRequestError(response: Response, error: unknown): Response;
 export declare function consumeFrameworkRequestRoute(response: Response): Response;
 export declare function traceFrameworkRequest<T>(input: RequestTraceInput<T>): Promise<T>;
-//#endregion
+//#endregion
+export {};

package/dist/server/request-tracing.js

@@ -1,8 +1,8 @@
 import { getOrCreateAls } from "../shims/internal/als-registry.js";
 import { isFullyBufferedBody, markFullyBufferedBody, preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER } from "./headers.js";
 import { frameworkTracer } from "./tracer.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { getResponseStartCompletion } from "./response-start-tracing.js";
 //#region src/server/request-tracing.ts
 const activeRequestTrace = getOrCreateAls("vinext.requestTracing.als");

package/dist/server/response-start-tracing.js

@@ -1,4 +1,5 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { observeStreamConsumption } from "./defer-until-stream-consumed.js";
 import { frameworkTracer } from "./tracer.js";
 import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
 //#region src/server/response-start-tracing.ts
@@ -13,37 +14,14 @@ function createResponseStartSpanDescriptor() {
 	};
 }
 function traceResponseStartStream(stream, onSettled) {
-	const reader = stream.getReader();
 	const runInTraceContext = frameworkTracer.captureActiveContext();
-	let started = false;
-	return new ReadableStream({
-		async pull(controller) {
-			try {
-				const result = await reader.read();
-				if (result.done) {
-					onSettled();
-					controller.close();
-					return;
-				}
-				if (!started) {
-					started = true;
-					runInTraceContext(() => frameworkTracer.trace(createResponseStartSpanDescriptor(), () => void 0));
-					onSettled();
-				}
-				controller.enqueue(result.value);
-			} catch (error) {
-				onSettled();
-				controller.error(error);
-			}
+	return observeStreamConsumption(stream, {
+		onStart() {
+			runInTraceContext(() => frameworkTracer.trace(createResponseStartSpanDescriptor(), () => void 0));
+			onSettled();
 		},
-		async cancel(reason) {
-			try {
-				await reader.cancel(reason);
-			} finally {
-				onSettled();
-			}
-		}
-	}, { highWaterMark: 0 });
+		onFlush: onSettled
+	});
 }
 function traceResponseStartWithCompletion(response) {
 	const existing = tracedResponses.get(response);

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

@@ -0,0 +1,4 @@
+//#region src/server/rsc-render-stream.d.ts
+export type RscRawRenderer = (model: unknown, options?: unknown) => ReadableStream<Uint8Array>;
+export declare function createRscRenderer(render: RscRawRenderer): RscRawRenderer;
+//#endregion

package/dist/server/rsc-render-stream.js

@@ -0,0 +1,25 @@
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import { createRenderStreamCancellation } from "./app-render-abort-error.js";
+//#region src/server/rsc-render-stream.ts
+const noop = () => {};
+function createRscRenderer(render) {
+	return (model, options) => {
+		const cancellation = createRenderStreamCancellation();
+		return deferUntilStreamConsumed(render(model, ignoreCancellationErrors(options, cancellation)), noop, void 0, cancellation.record);
+	};
+}
+/** A consumer cancelling the payload is not a render failure. */
+function ignoreCancellationErrors(options, cancellation) {
+	if (!options || typeof options !== "object") return options;
+	const onError = Reflect.get(options, "onError");
+	if (typeof onError !== "function") return options;
+	return {
+		...options,
+		onError(error, ...rest) {
+			if (cancellation.isReason(error)) return void 0;
+			return Reflect.apply(onError, options, [error, ...rest]);
+		}
+	};
+}
+//#endregion
+export { createRscRenderer };

package/dist/server/seed-cache.d.ts

@@ -30,4 +30,5 @@ type PrerenderCacheSeedOptions = {
  * @returns The number of routes seeded (0 if no manifest or no renderable routes).
  */
 export declare function seedMemoryCacheFromPrerender(serverDir: string, options?: PrerenderCacheSeedOptions): Promise<number>;
-//#endregion
+//#endregion
+export {};