vinext 1.3.1 → 1.4.1

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

@@ -1,9 +1,10 @@
 import { VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import { applyMiddlewareResponseHeadersToRequest } from "../utils/middleware-request-headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "./headers.js";
 import { notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { attachRequestCfMetadata, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
+import { attachRequestCfMetadata, cloneRequestWithUrl, filterInternalHeaders, guardProtocolRelativeUrl, haveSameHeaders, stripRequestUrlFragment, withRequestHeaders } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
@@ -22,7 +23,8 @@ import { resolveClientBuildFile } from "./client-build-files.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse, isWorkerPrerenderDiscoveryPath } from "./worker-prerender-discovery.js";
 import { getPagesResponseStageCacheDisposition } from "./pages-response-stage.js";
-import "./worker-stages.js";
+import { adapterUsesSharedCacheIdentity, pagesCacheIdentityOrigin, pagesPageSharesAcrossHosts } from "./shared-cache-identity.js";
+import { createSharedPagesPageCacheIdentity } from "./worker-stages.js";
 import { consumePagesResponseStagePolicyOwner, prependResponseStageAdditiveHeaders, withResponseStageVary, withoutResponseStageVary } from "./response-stage-policy.js";
 import * as configuredCdnCacheAdapters from "virtual:vinext-cdn-cache-adapter";
 import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
@@ -34,10 +36,14 @@ import * as pagesEntry from "virtual:vinext-pages-request-entry";
 * The public pages-router-entry delegates here. Multi-stage hosts import the
 * named request handler directly and provide their response-stage dispatcher.
 */
-function haveSameHeaders(first, second) {
-	const firstEntries = [...first];
-	const secondEntries = [...second];
-	return firstEntries.length === secondEntries.length && firstEntries.every(([name, value], index) => name === secondEntries[index]?.[0] && value === secondEntries[index]?.[1]);
+/**
+* Whether middleware's request-header overrides changed the request. Next.js
+* also copies ordinary middleware response headers onto the request; like a
+* client's own headers, those do not opt the render out of the shared stage.
+*/
+function hasRequestHeaderOverrides(originalHeaders, requestHeaders, middlewareResponseHeaders) {
+	const expectedHeaders = middlewareResponseHeaders ? applyMiddlewareResponseHeadersToRequest(originalHeaders, middlewareResponseHeaders) : originalHeaders;
+	return !haveSameHeaders(expectedHeaders, requestHeaders);
 }
 function captureOuterResponsePolicyHeaders(stagedHeaders, transportedPolicyHeaders) {
 	return captureCdnResponsePolicyOverrides(stagedHeaders, new Headers(transportedPolicyHeaders ?? []));
@@ -90,6 +96,7 @@ function handleRequestStageLocally(request, env, ctx, dispatchResponseStage) {
 	return handleRequest(request, env, ctx, (stageRequest, props, _options, stageEnv, stageCtx) => dispatchResponseStage(stageRequest, stageEnv, stageCtx, props), true, "worker", ctx?.assets).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest));
 }
 function handleRequest(request, env, platformCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets) {
+	request = stripRequestUrlFragment(request);
 	const url = new URL(request.url);
 	const trace = async () => {
 		await pagesEntry.__ensureInstrumentation?.(platformCtx);
@@ -151,7 +158,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			const expectedWorkerVersion = request.headers.get(VINEXT_EXPECTED_WORKER_VERSION_HEADER);
 			if (expectedWorkerVersion) filteredHeaders.set(VINEXT_EXPECTED_WORKER_VERSION_HEADER, expectedWorkerVersion);
 		}
-		request = cloneRequestWithHeaders(request, filteredHeaders);
+		request = withRequestHeaders(request, filteredHeaders);
 		const url = new URL(request.url);
 		let pathname = url.pathname;
 		if (ctx.isPrerenderPathDiscovery && isWorkerPrerenderDiscoveryPath(pathname)) return trackedDispatchResponseStage(request, {
@@ -162,7 +169,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 				resolvedRoutePathname: pathname
 			},
 			kind: "pages-prerender-discovery",
-			protocolVersion: 5,
+			protocolVersion: 6,
 			requestHost: url.host,
 			stagedHeaders: null
 		}, { cache: "bypass" }, env, ctx);
@@ -212,6 +219,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			requestContext: requestContextFromRequest(request)
 		});
 		let speculativeRenderRequest = null;
+		let middlewareResponseHeaders;
 		const deps = {
 			assetPrefix: vinextConfig?.assetPrefix,
 			basePath,
@@ -233,7 +241,15 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
 			matchApiRoute: typeof matchApiRoute === "function" ? matchApiRoute : null,
 			matchPageRoute: typeof matchPageRoute === "function" ? matchPageRoute : null,
-			runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) : null,
+			runMiddleware: typeof runMiddleware === "function" ? async (middlewareInput, middlewareCtx, middlewareOptions) => {
+				const result = await wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath)(middlewareInput, middlewareCtx, middlewareOptions);
+				middlewareResponseHeaders = void 0;
+				if (result.responseHeaders) {
+					middlewareResponseHeaders = new Headers();
+					for (const [key, value] of result.responseHeaders) middlewareResponseHeaders.append(key, value);
+				}
+				return result;
+			} : null,
 			renderPage: (req, resolvedUrl, options, stagedHeaders) => {
 				if (options?.renderErrorPageOnMiss === false && req.body !== null && !req.bodyUsed) speculativeRenderRequest = req;
 				const stageRequest = speculativeRenderRequest === req && req.body !== null && !req.bodyUsed ? attachRequestCfMetadata(req.clone(), req) : req;
@@ -242,11 +258,12 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 					authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
 					hasRequestAwareDocument: hasRequestAwareDocument === true,
 					request: req,
-					requestHeadersChanged: !haveSameHeaders(filteredHeaders, req.headers),
+					requestHeadersChanged: hasRequestHeaderOverrides(filteredHeaders, req.headers, middlewareResponseHeaders),
 					routeDataKind: matchedPage?.route.dataKind,
 					stagedHeaders
 				});
 				const isSharedStaticPage = cache === "shared" && matchedPage?.route.dataKind === "static";
+				const sharedAcrossHosts = (cache === "shared" || probeMode !== null) && pagesPageSharesAcrossHosts(matchedPage?.route) && adapterUsesSharedCacheIdentity();
 				const transportedPolicyHeaders = isSharedStaticPage ? withoutResponseStageVary(responseStagePolicyHeaders) : withResponseStageVary(responseStagePolicyHeaders, stagedHeaders?.get("Vary"));
 				const responseStageProps = () => ({
 					buildId: pagesEntry.buildId,
@@ -257,17 +274,22 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(resolvedUrl, req.url).pathname
 					},
 					kind: "pages-page",
-					protocolVersion: 5,
+					protocolVersion: 6,
 					requestHost: new URL(req.url).host,
 					renderOptions: isDataReq ? {
 						...options,
 						originalUrl: originalRenderUrl
 					} : options ?? null,
 					resolvedUrl,
+					sharedAcrossHosts,
 					stagedHeaders: isSharedStaticPage ? null : [...stagedHeaders ?? new Headers()]
 				});
 				const isHeadRequest = req.method.toUpperCase() === "HEAD";
-				const responsePromise = trackedDispatchResponseStage(stageRequest, responseStageProps(), { cache }, env, ctx).then((response) => {
+				const props = responseStageProps();
+				const responsePromise = trackedDispatchResponseStage(stageRequest, props, cache === "shared" && sharedAcrossHosts ? {
+					cache,
+					cacheIdentity: createSharedPagesPageCacheIdentity(stageRequest, props, pagesCacheIdentityOrigin(stageRequest.url, i18nConfig))
+				} : { cache }, env, ctx).then((response) => {
 					const consumed = consumePagesResponseStagePolicyOwner(response);
 					if (cache === "shared") {
 						if (isSharedStaticPage && stagedHeaders) prependResponseStageAdditiveHeaders(consumed.response.headers, stagedHeaders);
@@ -297,14 +319,14 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(apiUrl, req.url).pathname
 					},
 					kind: "pages-api",
-					protocolVersion: 5,
+					protocolVersion: 6,
 					requestHost: new URL(req.url).host,
 					stagedHeaders: [...stagedHeaders]
 				});
 				const cache = forceCacheBypass || probeMode ? "bypass" : getPagesResponseStageCacheDisposition({
 					authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
 					request: req,
-					requestHeadersChanged: !haveSameHeaders(filteredHeaders, req.headers),
+					requestHeadersChanged: hasRequestHeaderOverrides(filteredHeaders, req.headers, middlewareResponseHeaders),
 					stagedHeaders
 				});
 				const dispatched = trackedDispatchResponseStage(req, responseStageProps(), { cache }, env, ctx);

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

@@ -1,7 +1,7 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
 import "../shims/unified-request-context.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { beginRouteCacheability } from "../shims/cacheability-classification.js";
+import { beginRouteCacheability, markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
 import { validateCdnRequest } from "./cache-control.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
@@ -57,6 +57,12 @@ async function renderPagesResponse(request, env, platformCtx, props, stagedHeade
 		...ctx,
 		isStoredEntryRegeneration: true
 	};
+	let runtimeDataKind;
+	const runtimeDataKindIsRequestTime = () => {
+		if (props.kind !== "pages-page") return false;
+		runtimeDataKind ??= pagesEntry.getRuntimePageDataKind(props.resolvedUrl, request);
+		return runtimeDataKind === "server" || runtimeDataKind === "initial";
+	};
 	const render = async (cacheabilityContext) => {
 		if (props.kind === "pages-prerender-discovery") {
 			const readinessResponse = createWorkerPrerenderReadinessResponse(cacheabilityContext, request);
@@ -77,6 +83,7 @@ async function renderPagesResponse(request, env, platformCtx, props, stagedHeade
 			});
 		}
 		if (typeof pagesEntry.renderPage !== "function") return new Response("This page could not be found", { status: 404 });
+		if (props.sharedAcrossHosts && runtimeDataKindIsRequestTime()) runWithExecutionContext(cacheabilityContext, () => markRouteCacheabilityDynamic("getInitialProps render shares a cache entry across hosts"));
 		return stripStreamedHtmlContentLength(await pagesEntry.renderPage(request, props.resolvedUrl, null, cacheabilityContext, renderHeaders, props.renderOptions ?? void 0, initialResponseHeaders));
 	};
 	const handle = async (cacheabilityContext) => stripInheritedResponseStageCookies(await render(cacheabilityContext), renderHeaders);
@@ -94,9 +101,8 @@ async function renderPagesResponse(request, env, platformCtx, props, stagedHeade
 		resolvedRoutePathname: props.cacheability.resolvedRoutePathname
 	}, handle);
 	if (props.kind !== "pages-page") return response;
-	const runtimeDataKind = pagesEntry.getRuntimePageDataKind(props.resolvedUrl, request);
 	const headers = new Headers(response.headers);
-	headers.set(PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, runtimeDataKind === "server" || runtimeDataKind === "initial" ? "request-time" : "static");
+	headers.set(PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER, runtimeDataKindIsRequestTime() ? "request-time" : "static");
 	return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
 		headers,
 		status: response.status,

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

@@ -1,5 +1,5 @@
 import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM } from "./headers.js";
-import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
+import { cloneRequestWithHeaders, cloneRequestWithUrl, stripRequestUrlFragment } from "./request-pipeline.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { validateCdnRequest } from "./cache-control.js";
@@ -52,7 +52,8 @@ async function handleSingleStageRequest(request, env, platformCtx) {
 	return finalize ? finalize(response, ctx) : response;
 }
 var pages_router_entry_default = { fetch(request, env, ctx) {
-	const handle = () => handleSingleStageRequest(request, env, ctx);
+	const strippedRequest = stripRequestUrlFragment(request);
+	const handle = () => handleSingleStageRequest(strippedRequest, env, ctx);
 	return ctx && typeof ctx.waitUntil === "function" ? runWithExecutionContext(ctx, handle) : handle();
 } };
 //#endregion

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

@@ -102,11 +102,11 @@ declare function sendCompressed(req: IncomingMessage, res: ServerResponse, body:
  * Without a cache, falls back to async filesystem probing (still non-blocking,
  * unlike the old sync existsSync/statSync approach).
  *
- * `extraHeaders` go on every response for the file. `representationHeaders` go
+ * `stagedHeaders` go on every response for the file. `representationHeaders` go
  * only on responses that carry the file's bytes (200 and 206), never on a 304,
  * 412, 416 or 405.
  */
-declare function tryServeStatic(req: IncomingMessage, res: ServerResponse, clientDir: string, pathname: string, compress: boolean, cache?: StaticFileCache, extraHeaders?: Record<string, string | string[]>, statusCode?: number, representationHeaders?: Record<string, string>): Promise<boolean>;
+declare function tryServeStatic(req: IncomingMessage, res: ServerResponse, clientDir: string, pathname: string, compress: boolean, cache?: StaticFileCache, stagedHeaders?: Record<string, string | string[]>, statusCode?: number, representationHeaders?: Record<string, string>): Promise<boolean>;
 /**
  * Convert a Node.js IncomingMessage to a Web Request object.
  *

package/dist/server/prod-server.js

@@ -8,7 +8,7 @@ import { getRepeatedSlashRedirect, isOpenRedirectShaped, sendRepeatedSlashRedire
 import { readStaticFileSignal } from "./static-file-signal.js";
 import { canonicalizeRequestPathname, filterInternalHeaders } from "./request-pipeline.js";
 import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isAssetPrefixBuildAsset } from "../utils/asset-prefix.js";
-import { StaticFileCache, contentTypeForPath, etagFromFilenameHash } from "./static-file-cache.js";
+import { StaticFileCache, contentTypeForPath, etagFromFilenameHash, staticFileCacheControl } from "./static-file-cache.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { resolveRequestHost, resolveRequestProtocol, resolveTrustedForwardedHost, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { normalizePath } from "./normalize-path.js";
@@ -19,7 +19,7 @@ import { parseHttpDate } from "./http-date.js";
 import { evaluateStaticPreconditions } from "./http-conditional.js";
 import { setPagesClientAssets } from "./pages-client-assets.js";
 import { signalFromNodeResponse } from "./node-response-signal.js";
-import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_RESPONSE_CACHE_STATE, INVALID_IMAGE_SOURCE_MESSAGE, isImageOptimizationPath, isImageSourceBodyStatus, isSafeImageContentType, parseImageParams, readImageOptimizationSignal } from "./image-optimization.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_RESPONSE_CACHE_STATE, INVALID_IMAGE_SOURCE_MESSAGE, MUTABLE_IMAGE_SOURCE_CACHE_CONTROL, isImageOptimizationPath, isImageSourceBodyStatus, isSafeImageContentType, parseImageParams, readImageOptimizationSignal } from "./image-optimization.js";
 import { installSocketErrorBackstop } from "./socket-error-backstop.js";
 import { collectInlineCssManifest } from "../build/inline-css.js";
 import { readTrustedRevalidationHostname } from "./revalidation-host.js";
@@ -284,6 +284,16 @@ function readHeaderCaseInsensitive(headersRecord, name) {
 	const value = headersRecord[key];
 	return Array.isArray(value) ? value.join(", ") : value;
 }
+/** Spell a header's name as `name`, so spreading the record replaces that key. */
+function withHeaderName(headersRecord, name) {
+	const lowerName = name.toLowerCase();
+	const key = Object.keys(headersRecord).find((entry) => entry !== name && entry.toLowerCase() === lowerName);
+	if (key === void 0) return headersRecord;
+	const { [key]: value, ...rest } = headersRecord;
+	const existing = rest[name];
+	rest[name] = existing === void 0 ? value : [existing, value].flat();
+	return rest;
+}
 /** Remove one field name from a Vary header, dropping the header if it empties. */
 function omitVaryToken(headers, token) {
 	const varyKey = Object.keys(headers).find((key) => key.toLowerCase() === "vary");
@@ -464,6 +474,18 @@ function staticCacheLookupPath(pathname) {
 	if (lookupPath.startsWith("/.vite/") || lookupPath === "/.vite") return null;
 	return lookupPath;
 }
+/**
+* Give a Node image passthrough Next.js's image Cache-Control instead of the
+* public-file default: a hashed build asset keeps its immutable default, and
+* any other source is revalidated after the default `images.minimumCacheTTL`.
+*/
+function withImageSourceCacheControl(headers, sourcePath) {
+	if (sourcePath.includes(`/_next/static/`)) return headers;
+	return {
+		...headers,
+		"Cache-Control": MUTABLE_IMAGE_SOURCE_CACHE_CONTROL
+	};
+}
 /** Pathnames the Pages Router serves from routes rather than the client directory. */
 function isPagesFilesystemExcludedPath(pathname, phase) {
 	return pathname === "/" || pathname === "/api" || pathname.startsWith("/api/") || phase === "direct" && pathname.startsWith(`/_next/static/`);
@@ -479,12 +501,13 @@ function isPagesFilesystemExcludedPath(pathname, phase) {
 * Without a cache, falls back to async filesystem probing (still non-blocking,
 * unlike the old sync existsSync/statSync approach).
 *
-* `extraHeaders` go on every response for the file. `representationHeaders` go
+* `stagedHeaders` go on every response for the file. `representationHeaders` go
 * only on responses that carry the file's bytes (200 and 206), never on a 304,
 * 412, 416 or 405.
 */
-async function tryServeStatic(req, res, clientDir, pathname, compress, cache, extraHeaders, statusCode, representationHeaders) {
+async function tryServeStatic(req, res, clientDir, pathname, compress, cache, stagedHeaders, statusCode, representationHeaders) {
 	if (pathname === "/") return false;
+	const extraHeaders = stagedHeaders && withHeaderName(stagedHeaders, "Cache-Control");
 	const responseStatus = statusCode ?? 200;
 	const omitBody = isNoBodyResponseStatus(responseStatus);
 	const requestRange = req.method === "GET" || req.method === "HEAD" ? req.headers.range : void 0;
@@ -610,7 +633,7 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 	const ext = path.extname(resolved.path);
 	const ct = contentTypeForPath(resolved.path);
 	const isHashed = pathname.includes(`/${ASSET_PREFIX_URL_DIR}/`);
-	const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600";
+	const cacheControl = staticFileCacheControl(isHashed);
 	const etag = isHashed && etagFromFilenameHash(resolved.path, ext) || `W/"${resolved.size}-${Math.floor(resolved.mtimeMs / 1e3)}"`;
 	const baseHeaders = {
 		"Content-Type": ct,
@@ -798,6 +821,15 @@ async function statIfFile(filePath) {
 	}
 }
 /**
+* Node's parser keeps a `#fragment` sent on the request line in `req.url`.
+* Next.js rebuilds request URLs from pathname + search, so neither routing,
+* middleware nor handlers observe one; drop it before anything reads the URL.
+*/
+function stripNodeRequestUrlFragment(req) {
+	const hashIndex = req.url?.indexOf("#") ?? -1;
+	if (hashIndex !== -1) req.url = req.url?.slice(0, hashIndex);
+}
+/**
 * Convert a Node.js IncomingMessage to a Web Request object.
 *
 * When `urlOverride` is provided, it is used as the path + query string
@@ -1182,7 +1214,7 @@ async function startAppRouterServer(options) {
 			"X-Content-Type-Options": "nosniff",
 			"Content-Disposition": imageConfig?.contentDispositionType === "attachment" ? "attachment" : "inline"
 		};
-		const serveSource = (sourcePath) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, imageSecurityHeaders, void 0, IMAGE_REPRESENTATION_HEADERS);
+		const serveSource = (sourcePath) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, withImageSourceCacheControl(imageSecurityHeaders, sourcePath), void 0, IMAGE_REPRESENTATION_HEADERS);
 		const sourceUrl = new URL(params.imageUrl, request.url);
 		let sourcePathname = null;
 		try {
@@ -1299,6 +1331,7 @@ async function startAppRouterServer(options) {
 		}
 	};
 	const handleRequest = async (req, res) => {
+		stripNodeRequestUrlFragment(req);
 		try {
 			await ensureInstrumentation();
 		} catch (error) {
@@ -1319,7 +1352,7 @@ async function startAppRouterServer(options) {
 			},
 			getStatus: () => res.statusCode,
 			headers,
-			isRsc: target.split("?", 1)[0].endsWith(".rsc") || headers.get("RSC") === "1",
+			isRsc: headers.get("RSC") === "1",
 			method: req.method ?? "GET",
 			target
 		});
@@ -1434,6 +1467,7 @@ async function createPagesRouterRequestHandler(options) {
 	});
 	const staticCache = await StaticFileCache.create(clientDir);
 	const handleRequest = async (req, res) => {
+		stripNodeRequestUrlFragment(req);
 		try {
 			await ensureInstrumentation();
 		} catch (error) {
@@ -1646,7 +1680,11 @@ async function createPagesRouterRequestHandler(options) {
 					...options,
 					originalUrl: originalRenderUrl
 				}, stagedHeaders?.has("Cache-Control") ? new Headers({ "Cache-Control": stagedHeaders.get("Cache-Control") }) : void 0) : null,
-				handleApi: typeof handleApi === "function" ? (request, apiUrl) => handleApi(request, apiUrl, createNodeExecutionContext(), resolveTrustedNodeRevalidateOrigin(req, host, port), "node") : null,
+				handleApi: typeof handleApi === "function" ? (request, apiUrl, _ctx, stagedHeaders) => {
+					stagedHeaders.delete("Content-Length");
+					return handleApi(request, apiUrl, createNodeExecutionContext(), resolveTrustedNodeRevalidateOrigin(req, host, port), "node", stagedHeaders);
+				} : null,
+				handleApiAppliesStagedHeaders: true,
 				serveFilesystemRoute: async (requestPathname, stagedHeaders, phase, resolvedUrl, _request, resolvedPathnameHasBasePath) => {
 					if (resolvedPathnameHasBasePath && isImageOptimizationPath(requestPathname)) {
 						for (const [name, value] of Object.entries(stagedHeaders)) res.setHeader(name, value);
@@ -1667,7 +1705,7 @@ async function createPagesRouterRequestHandler(options) {
 							"X-Content-Type-Options": "nosniff",
 							"Content-Disposition": pagesImageConfig?.contentDispositionType === "attachment" ? "attachment" : "inline"
 						};
-						const serveSource = (sourcePath) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, imageSecurityHeaders, void 0, IMAGE_REPRESENTATION_HEADERS);
+						const serveSource = (sourcePath) => tryServeStatic(req, res, clientDir, sourcePath, false, staticCache, withImageSourceCacheControl(imageSecurityHeaders, sourcePath), void 0, IMAGE_REPRESENTATION_HEADERS);
 						const sourceUrl = new URL(params.imageUrl, webRequest.url);
 						let sourcePathname = null;
 						try {

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

@@ -0,0 +1,9 @@
+//#region src/server/request-error-log.d.ts
+/**
+ * Logs an error vinext also passes to instrumentation's `onRequestError`, as
+ * `next start` logs it. `VINEXT_QUIET=1` turns these logs off, like Next.js'
+ * `quiet` server option, so an `onRequestError` that redacts errors before
+ * recording them is the only place they reach.
+ */
+export declare function logRequestError(...args: unknown[]): void;
+//#endregion

package/dist/server/request-error-log.js

@@ -0,0 +1,13 @@
+//#region src/server/request-error-log.ts
+/**
+* Logs an error vinext also passes to instrumentation's `onRequestError`, as
+* `next start` logs it. `VINEXT_QUIET=1` turns these logs off, like Next.js'
+* `quiet` server option, so an `onRequestError` that redacts errors before
+* recording them is the only place they reach.
+*/
+function logRequestError(...args) {
+	if (process.env.VINEXT_QUIET === "1") return;
+	console.error(...args);
+}
+//#endregion
+export { logRequestError };

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

@@ -73,7 +73,6 @@ type ResolvePublicFileRouteOptions = {
   middlewareContext: StaticFileSignalContext & {
     requestHeaders?: Headers | null;
   };
-  pathname: string;
   publicFiles: ReadonlySet<string>;
   request: Request;
 };
@@ -82,7 +81,7 @@ type ResolvePublicFileRouteOptions = {
  *
  * Public files are checked after middleware and before afterFiles/fallback
  * rewrites. The generated App Router entry provides the public-file set; this
- * helper owns the RSC exclusion, existence-first method enforcement, and
+ * helper owns existence-first method enforcement and
  * static-file signaling. Missing mutation targets continue through routing.
  */
 export declare function resolvePublicFileRoute(options: ResolvePublicFileRouteOptions): Response | null;
@@ -91,8 +90,8 @@ export declare function normalizeTrailingSlashPathname(pathname: string, trailin
  * Check if the pathname needs a trailing slash redirect, and return the
  * redirect Response if so.
  *
- * Follows Next.js behavior:
- * - `/api` routes are never redirected
+ * Follows Next.js behavior, whose internal trailing-slash redirects cover
+ * every path, `/api` included:
  * - The root path `/` is never redirected
  * - If `trailingSlash` is true, redirect `/about` → `/about/`
  * - If `trailingSlash` is true, redirect file-looking `/file.ext/` → `/file.ext`
@@ -181,6 +180,12 @@ export declare function attachRequestCfMetadata(target: Request, source: Request
  * a RequestInit with best-effort metadata.
  */
 export declare function cloneRequestWithHeaders(request: Request, headers: Headers): Request;
+export declare function haveSameHeaders(first: Headers, second: Headers): boolean;
+/**
+ * `cloneRequestWithHeaders`, except that a native request whose headers
+ * already match is returned as is, so its body stays where it is.
+ */
+export declare function withRequestHeaders(request: Request, headers: Headers): Request;
 /**
  * Clone a Request while overriding the URL, preserving headers and metadata
  * when possible.
@@ -194,5 +199,11 @@ export declare function cloneRequestWithHeaders(request: Request, headers: Heade
  * exists.
  */
 export declare function cloneRequestWithUrl(request: Request, url: string): Request;
+/**
+ * Drop a `#fragment` the host kept from the request line. Next.js rebuilds
+ * request URLs from pathname + search, so neither middleware nor handlers
+ * ever observe one, and pathname-keyed cache entries must not either.
+ */
+export declare function stripRequestUrlFragment(request: Request): Request;
 //#endregion
 export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, createStaticFileSignal, getRepeatedSlashRedirect, hasBasePath, isOpenRedirectShaped, sendRepeatedSlashRedirect, stripBasePath };

package/dist/server/request-pipeline.js

@@ -84,7 +84,8 @@ function guardProtocolRelativeUrl(rawPathname, search = "") {
 	if (isOpenRedirectShaped(rawPathname)) return notFoundResponse();
 	return null;
 }
-const FILE_LIKE_PATHNAME_RE = /\.[^/]+\/?$/;
+const SLASHED_FILE_PATHNAME_RE = /^\/(?:[^/]+\/)*[^/]+\.\w+\/$/;
+const UNSLASHED_NON_FILE_PATHNAME_RE = /^\/(?:[^/]+\/)*[^/.]+$/;
 function isWellKnownPathname(pathname) {
 	return pathname === "/.well-known" || pathname.startsWith("/.well-known/");
 }
@@ -93,37 +94,32 @@ function isWellKnownPathname(pathname) {
 *
 * Public files are checked after middleware and before afterFiles/fallback
 * rewrites. The generated App Router entry provides the public-file set; this
-* helper owns the RSC exclusion, existence-first method enforcement, and
+* helper owns existence-first method enforcement and
 * static-file signaling. Missing mutation targets continue through routing.
 */
 function resolvePublicFileRoute(options) {
-	if (options.pathname.endsWith(".rsc")) return null;
 	if (!options.publicFiles.has(options.cleanPathname)) return null;
 	if (options.request.method !== "GET" && options.request.method !== "HEAD") return methodNotAllowedResponse("GET, HEAD", { headers: options.middlewareContext.headers ?? void 0 });
 	const { requestHeaders } = options.middlewareContext;
 	return createStaticFileSignal(options.cleanPathname, options.middlewareContext, requestHeaders ? buildRequestHeadersFromMiddlewareResponse(options.request.headers, requestHeaders) : null);
 }
 function normalizeTrailingSlashPathname(pathname, trailingSlash) {
-	if (pathname === "/" || pathname === "/api" || pathname.startsWith("/api/")) return null;
-	const hasTrailing = pathname.endsWith("/");
+	if (pathname === "/") return null;
 	if (trailingSlash) {
 		if (isWellKnownPathname(pathname)) return null;
-		if (FILE_LIKE_PATHNAME_RE.test(pathname)) {
-			const normalized = removeTrailingSlash(pathname);
-			return normalized === pathname ? null : normalized;
-		}
-		if (!hasTrailing && !pathname.endsWith(".rsc")) return `${pathname}/`;
+		if (SLASHED_FILE_PATHNAME_RE.test(pathname)) return pathname.slice(0, -1);
+		if (UNSLASHED_NON_FILE_PATHNAME_RE.test(pathname)) return `${pathname}/`;
 		return null;
 	}
-	if (hasTrailing) return removeTrailingSlash(pathname);
+	if (pathname.endsWith("/")) return removeTrailingSlash(pathname);
 	return null;
 }
 /**
 * Check if the pathname needs a trailing slash redirect, and return the
 * redirect Response if so.
 *
-* Follows Next.js behavior:
-* - `/api` routes are never redirected
+* Follows Next.js behavior, whose internal trailing-slash redirects cover
+* every path, `/api` included:
 * - The root path `/` is never redirected
 * - If `trailingSlash` is true, redirect `/about` → `/about/`
 * - If `trailingSlash` is true, redirect file-looking `/file.ext/` → `/file.ext`
@@ -137,7 +133,7 @@ function normalizeTrailingSlashPathname(pathname, trailingSlash) {
 * @returns A 308 redirect Response, or null if no redirect is needed
 */
 function normalizeTrailingSlash(pathname, basePath, trailingSlash, search) {
-	if (pathname === "/" || pathname === "/api" || pathname.startsWith("/api/")) return null;
+	if (pathname === "/") return null;
 	if (isOpenRedirectShaped(pathname)) return notFoundResponse();
 	const normalizedPathname = normalizeTrailingSlashPathname(pathname, trailingSlash);
 	if (normalizedPathname === null) return null;
@@ -407,6 +403,26 @@ function cloneRequestWithHeaders(request, headers) {
 	}
 	return attachRequestCfMetadata(cloned, request);
 }
+function haveSameHeaders(first, second) {
+	const firstEntries = [...first];
+	const secondEntries = [...second];
+	return firstEntries.length === secondEntries.length && firstEntries.every(([name, value], index) => name === secondEntries[index]?.[0] && value === secondEntries[index]?.[1]);
+}
+function isNativeRequest(request) {
+	try {
+		Reflect.get(Request.prototype, "url", request);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* `cloneRequestWithHeaders`, except that a native request whose headers
+* already match is returned as is, so its body stays where it is.
+*/
+function withRequestHeaders(request, headers) {
+	return isNativeRequest(request) && haveSameHeaders(headers, request.headers) ? request : cloneRequestWithHeaders(request, headers);
+}
 /**
 * Clone a Request while overriding the URL, preserving headers and metadata
 * when possible.
@@ -443,5 +459,17 @@ function cloneRequestWithUrl(request, url) {
 	}
 	return attachRequestCfMetadata(cloned, request);
 }
+/**
+* Drop a `#fragment` the host kept from the request line. Next.js rebuilds
+* request URLs from pathname + search, so neither middleware nor handlers
+* ever observe one, and pathname-keyed cache entries must not either.
+*/
+function stripRequestUrlFragment(request) {
+	const hashIndex = request.url.indexOf("#");
+	if (hashIndex === -1) return request;
+	const signal = request.signal;
+	const stripped = cloneRequestWithUrl(request, request.url.slice(0, hashIndex));
+	return attachRequestCfMetadata(new Request(stripped, { signal }), request);
+}
 //#endregion
-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 };
+export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, attachRequestCfMetadata, canonicalizeRequestPathname, canonicalizeRequestUrlPathname, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, dropEmptyMiddlewareSetCookie, filterInternalHeaders, getRepeatedSlashRedirect, guardProtocolRelativeUrl, hasBasePath, haveSameHeaders, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, sendRepeatedSlashRedirect, stripBasePath, stripRequestUrlFragment, validateCsrfOrigin, validateServerActionPayload, withRequestHeaders };

package/dist/server/rsc-completion-metadata.js

@@ -88,9 +88,11 @@ function extractRscCompletionMetadata(buffer) {
 }
 function appendRscCompletionMetadata(source, getMetadata) {
 	const reader = source.getReader();
+	let cancelled = false;
 	return new ReadableStream({
 		async pull(controller) {
 			const next = await reader.read();
+			if (cancelled) return;
 			if (!next.done) {
 				controller.enqueue(escapeFlightChunk(next.value));
 				return;
@@ -100,6 +102,7 @@ function appendRscCompletionMetadata(source, getMetadata) {
 			controller.close();
 		},
 		cancel(reason) {
+			cancelled = true;
 			return reader.cancel(reason);
 		}
 	});

package/dist/server/shared-cache-identity.d.ts

@@ -0,0 +1,23 @@
+import { NextI18nConfig } from "../config/next-config.js";
+//#region src/server/shared-cache-identity.d.ts
+/** The core cache identity the configured adapter keys shared dispatches by, if any. */
+export declare function adapterSharedCacheIdentity(): "host-free" | "query-free" | null;
+/** Whether the configured adapter keys shared dispatches by a core cache identity. */
+export declare function adapterUsesSharedCacheIdentity(): boolean;
+/**
+ * Whether a Pages page's response is one for every host, as Next.js serves a
+ * getStaticProps page and an automatically static page. A page without data
+ * functions is rendered per request when its getInitialProps or a custom
+ * _app's runs, and may read the host, so it keeps the host in its key.
+ */
+export declare function pagesPageSharesAcrossHosts(route: {
+  dataKind?: string;
+  runsInitialProps?: boolean;
+} | null | undefined): boolean;
+/**
+ * The origin a shared Pages page identity names. A static Pages render reads
+ * the host only to select a configured i18n domain, so the identity keeps that
+ * domain, as vinext's Pages ISR key does, and every other host shares one entry.
+ */
+export declare function pagesCacheIdentityOrigin(requestUrl: string, i18nConfig: NextI18nConfig | null | undefined): string;
+//#endregion

package/dist/server/shared-cache-identity.js

@@ -0,0 +1,36 @@
+import { detectDomainLocale, normalizeDomainHostname } from "../utils/domain-locale.js";
+import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
+import { VINEXT_CACHE_IDENTITY_ORIGIN } from "./multi-stage.js";
+//#region src/server/shared-cache-identity.ts
+/** The core cache identity the configured adapter keys shared dispatches by, if any. */
+function adapterSharedCacheIdentity() {
+	const adapter = getCdnCacheAdapter();
+	if (adapter.requiresCompletedResponseAdmission !== true) return null;
+	return adapter.responseStageCacheIdentity ?? null;
+}
+/** Whether the configured adapter keys shared dispatches by a core cache identity. */
+function adapterUsesSharedCacheIdentity() {
+	return adapterSharedCacheIdentity() !== null;
+}
+/**
+* Whether a Pages page's response is one for every host, as Next.js serves a
+* getStaticProps page and an automatically static page. A page without data
+* functions is rendered per request when its getInitialProps or a custom
+* _app's runs, and may read the host, so it keeps the host in its key.
+*/
+function pagesPageSharesAcrossHosts(route) {
+	if (route?.dataKind === "static") return true;
+	return route?.dataKind === "none" && route.runsInitialProps !== true;
+}
+/**
+* The origin a shared Pages page identity names. A static Pages render reads
+* the host only to select a configured i18n domain, so the identity keeps that
+* domain, as vinext's Pages ISR key does, and every other host shares one entry.
+*/
+function pagesCacheIdentityOrigin(requestUrl, i18nConfig) {
+	const domainLocale = detectDomainLocale(i18nConfig?.domains, new URL(requestUrl).hostname);
+	if (!domainLocale) return VINEXT_CACHE_IDENTITY_ORIGIN;
+	return `${domainLocale.http ? "http" : "https"}://${normalizeDomainHostname(domainLocale.domain)}`;
+}
+//#endregion
+export { adapterSharedCacheIdentity, adapterUsesSharedCacheIdentity, pagesCacheIdentityOrigin, pagesPageSharesAcrossHosts };