vinext 1.1.0 → 1.2.0

package/dist/server/pages-page-response.js

@@ -2,22 +2,25 @@ import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { NEXTJS_CACHE_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER } from "./headers.js";
 import { reportRequestError } from "./instrumentation.js";
+import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { markRouteCacheabilityExplicitResponsePolicy } from "../shims/cacheability-classification.js";
 import { BROWSER_REVALIDATE_CACHE_CONTROL, NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy, shouldUseNextDeployCacheControl } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
-import { fnv1a52 } from "../utils/hash.js";
 import { isrCacheControl } from "./isr-cache.js";
-import { encodeCacheTag } from "../utils/encode-cache-tag.js";
+import { fnv1a52 } from "../utils/hash.js";
 import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createNonceAttribute, escapeHtmlAttr } from "./html.js";
+import { createDocumentPlaceholderToken, withDocumentPlaceholders } from "../shims/document-placeholders.js";
 import { applyDocumentAssetProps, extractDocumentAssetProps } from "./pages-document-asset-props.js";
+import { spliceDocumentHeadClose, spliceDocumentHeadOpen, spliceDocumentScripts, splitDocumentAtMain } from "./pages-document-splice.js";
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
+import { pagesPathCacheTag } from "./pages-cache-tag.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { loadUserDocumentInitialProps, runDocumentRenderPage } from "./pages-document-initial-props.js";
 import { callDocumentGetInitialProps } from "./document-initial-head.js";
-import { matchesIfNoneMatch } from "./http-conditional.js";
+import { isPageNotModified } from "./http-conditional.js";
 import React from "react";
 //#region src/server/pages-page-response.ts
 /**
@@ -31,14 +34,13 @@ function generatePagesETag(payload) {
 	return "\"" + fnv1a52(payload).toString(36) + payload.length.toString(36) + "\"";
 }
 /**
-* Returns true when a request `Cache-Control` header asks to bypass the 304
-* short-circuit. Mirrors the `fresh` package's check used by Next.js's
-* `sendEtagResponse` (`/(?:^|,)\s*?no-cache\s*?(?:,|$)/`). Shared by the
-* fresh-MISS bot path here and the ISR HIT/STALE paths in
-* `pages-page-data.ts` so the two cannot drift.
+* Whether a render answers a matching If-None-Match with a 304. Next.js stores
+* the page before it evaluates the ETag, so when the CDN adapter stores the
+* completed response, the render returns the page and the adapter sends the 304.
+* A page whose status carries no body has nothing to store.
 */
-function requestsNoCache(cacheControl) {
-	return /(?:^|,)\s*no-cache\s*(?:,|$)/.test(cacheControl ?? "");
+function rendersPagesNotModified(status) {
+	return status === 204 || status === 205 || status === 304 || getCdnCacheAdapter().deferNotModifiedResponse?.() !== true;
 }
 function buildPagesFontHeadHtml(fontLinks, fontPreloads, fontStyles, scriptNonce) {
 	let html = "";
@@ -71,33 +73,34 @@ function buildPagesNextDataScript(options) {
 	};
 	return `<script id="__NEXT_DATA__" type="application/json"${createNonceAttribute(options.scriptNonce)}>${options.safeJsonStringify(nextDataPayload)}<\/script>`;
 }
-async function buildPagesShellHtml(bodyMarker, fontHeadHTML, nextDataScript, options) {
+async function buildPagesShellHtml(fontHeadHTML, nextDataScript, options) {
 	if (options.DocumentComponent) {
 		const docProps = options.resolvedDocProps ?? await loadUserDocumentInitialProps(options.DocumentComponent);
 		const docElement = docProps ? React.createElement(options.DocumentComponent, docProps) : React.createElement(options.DocumentComponent);
-		const renderedDocument = extractDocumentAssetProps(await options.renderDocumentToString(docElement));
+		const token = createDocumentPlaceholderToken();
+		const renderedDocument = extractDocumentAssetProps(await options.renderDocumentToString(withDocumentPlaceholders(docElement, token)), token);
 		let html = renderedDocument.html;
 		const generatedAssetTags = applyDocumentAssetProps(options.assetTags, renderedDocument.props, {
 			configuredCrossOrigin: options.crossOrigin,
 			scriptOwner: options.disableOptimizedLoading ? "next-script" : "head"
 		});
 		const generatedNextDataScript = applyDocumentAssetProps(nextDataScript, renderedDocument.props, { configuredCrossOrigin: options.crossOrigin });
-		html = html.replace("__NEXT_MAIN__", bodyMarker);
-		if (options.ssrHeadHTML) html = html.replace(/<head(?:\s[^>]*)?>/i, (openingHead) => `${openingHead}${options.ssrHeadHTML}`);
-		if (generatedAssetTags || fontHeadHTML || options.tailHeadHTML) html = html.replace("</head>", `  ${fontHeadHTML}\n  ${generatedAssetTags}\n  ${options.tailHeadHTML}\n</head>`);
-		html = html.replace("<!-- __NEXT_SCRIPTS__ -->", generatedNextDataScript);
-		if (!html.includes("__NEXT_DATA__")) html = html.replace("</body>", `  ${generatedNextDataScript}\n</body>`);
-		return html;
+		html = spliceDocumentHeadOpen(html, token, options.ssrHeadHTML);
+		html = spliceDocumentHeadClose(html, token, generatedAssetTags || fontHeadHTML || options.tailHeadHTML ? `  ${fontHeadHTML}\n  ${generatedAssetTags}\n  ${options.tailHeadHTML}\n` : "");
+		html = spliceDocumentScripts(html, token, generatedNextDataScript);
+		return splitDocumentAtMain(html, token);
 	}
 	const generatedAssetTags = applyDocumentAssetProps(options.assetTags, {}, { configuredCrossOrigin: options.crossOrigin });
 	const generatedNextDataScript = applyDocumentAssetProps(nextDataScript, {}, { configuredCrossOrigin: options.crossOrigin });
-	return `<!DOCTYPE html>
+	return {
+		prefix: `<!DOCTYPE html>
 <html>
 <head>
   ${options.ssrHeadHTML}${fontHeadHTML}\n  ${generatedAssetTags}\n  ${options.tailHeadHTML}\n</head>
 <body>
-  <div id="__next">${bodyMarker}</div>\n  ${generatedNextDataScript}\n</body>
-</html>`;
+  <div id="__next">`,
+		suffix: `</div>\n  ${generatedNextDataScript}\n</body>\n</html>`
+	};
 }
 async function buildPagesCompositeStream(bodyStream, shellPrefix, shellSuffix) {
 	const encoder = new TextEncoder();
@@ -182,7 +185,6 @@ async function renderPagesPageResponse(options) {
 		nextData: options.nextData,
 		vinext: options.vinext
 	});
-	const bodyMarker = "<!--VINEXT_STREAM_BODY-->";
 	const documentResult = await (options.traceDocument ?? ((callback) => callback()))(async () => {
 		const documentRenderPage = await runDocumentRenderPage({
 			DocumentComponent: options.DocumentComponent,
@@ -200,7 +202,7 @@ async function renderPagesPageResponse(options) {
 				asPath: options.routeUrl
 			}
 		});
-		if (options.documentReqRes?.res.headersSent && options.documentReqRes.responsePromise) return {
+		if (!options.isStaticPropsRoute && options.documentReqRes?.res.headersSent && options.documentReqRes.responsePromise) return {
 			documentRenderPage,
 			responseSent: true
 		};
@@ -233,7 +235,7 @@ async function renderPagesPageResponse(options) {
 		if (tailHeadHTML) tailHeadHTML += "\n  ";
 		tailHeadHTML += documentRenderPage.stylesHTML;
 	}
-	const shellHtml = await buildPagesShellHtml(bodyMarker, fontHeadHTML, nextDataScript, {
+	const { prefix: shellPrefix, suffix: shellSuffix } = await buildPagesShellHtml(fontHeadHTML, nextDataScript, {
 		assetTags: options.assetTags,
 		disableOptimizedLoading: options.disableOptimizedLoading,
 		DocumentComponent: options.DocumentComponent,
@@ -244,9 +246,6 @@ async function renderPagesPageResponse(options) {
 		crossOrigin: options.crossOrigin
 	});
 	options.clearSsrContext();
-	const markerIndex = shellHtml.indexOf(bodyMarker);
-	const shellPrefix = shellHtml.slice(0, markerIndex);
-	const shellSuffix = shellHtml.slice(markerIndex + 25);
 	const responseHeaders = new Headers({ "Content-Type": "text/html; charset=utf-8" });
 	const finalStatus = applyGsspHeaders(responseHeaders, options.gsspRes ?? options.documentReqRes?.res ?? null, options.statusCode);
 	let responseBodyStream = bodyStream;
@@ -264,26 +263,30 @@ async function renderPagesPageResponse(options) {
 			setCache: options.isrSet,
 			shellPrefix,
 			shellSuffix,
-			status: finalStatus,
+			status: options.isStaticPropsRoute ? options.statusCode ?? 200 : finalStatus,
 			stream: cacheBodyStream
 		};
-		if (options.isOnDemandRevalidate) await writePagesIsrCache(cacheWriteOptions);
+		if (options.isOnDemandRevalidate || options.isStaleRegeneration) await writePagesIsrCache(cacheWriteOptions);
 		else schedulePagesIsrCacheWrite(cacheWriteOptions);
 	}
+	if (!options.isOnDemandRevalidate && options.documentReqRes?.res.headersSent && options.documentReqRes.responsePromise) {
+		responseBodyStream.cancel().catch(() => {});
+		return options.documentReqRes.responsePromise;
+	}
 	const compositeStream = await buildPagesCompositeStream(responseBodyStream, shellPrefix, shellSuffix);
 	const userSetCacheControl = responseHeaders.has("Cache-Control");
 	if (hasCdnResponsePolicy(responseHeaders)) markRouteCacheabilityExplicitResponsePolicy();
 	if (options.scriptNonce) responseHeaders.set("Cache-Control", NO_STORE_CACHE_CONTROL);
 	else if (options.isrRevalidateSeconds !== null) {
 		const isrPathname = options.isrCachePathname ?? options.routeUrl.split("?")[0];
-		const stem = isrPathname.endsWith("/") ? isrPathname.slice(0, -1) : isrPathname;
+		const pathTag = pagesPathCacheTag(isrPathname);
 		applyCdnResponseHeaders(responseHeaders, {
 			cacheControl: buildMissIsrCacheControl(options.isrRevalidateSeconds, options.expireSeconds),
-			tags: [encodeCacheTag(`_N_T_${stem || "/"}`)]
+			tags: [pathTag]
 		});
 		if (options.isOnDemandRevalidate) {
 			responseHeaders.set(NEXTJS_CACHE_HEADER, "REVALIDATED");
-			responseHeaders.set(VINEXT_REVALIDATED_CACHE_TAG_HEADER, encodeCacheTag(`_N_T_${stem || "/"}`));
+			responseHeaders.set(VINEXT_REVALIDATED_CACHE_TAG_HEADER, encodeURIComponent(pathTag));
 		} else setCacheStateHeaders(responseHeaders, "MISS");
 	} else if (options.isStaticPropsRoute && shouldUseNextDeployCacheControl()) responseHeaders.set("Cache-Control", BROWSER_REVALIDATE_CACHE_CONTROL);
 	else if (options.gsspRes && !userSetCacheControl) responseHeaders.set("Cache-Control", NEVER_CACHE_CONTROL);
@@ -292,7 +295,11 @@ async function renderPagesPageResponse(options) {
 		const fullHtml = await readStreamAsText(compositeStream);
 		const etag = generatePagesETag(fullHtml);
 		responseHeaders.set("ETag", etag);
-		if (!requestsNoCache(options.requestCacheControl) && options.ifNoneMatch && matchesIfNoneMatch(options.ifNoneMatch, etag)) return new Response(null, {
+		if (isPageNotModified({
+			cacheControl: options.requestCacheControl,
+			ifModifiedSince: options.ifModifiedSince,
+			ifNoneMatch: options.ifNoneMatch
+		}, etag) && rendersPagesNotModified(finalStatus)) return new Response(null, {
 			status: 304,
 			headers: responseHeaders
 		});
@@ -307,4 +314,4 @@ async function renderPagesPageResponse(options) {
 	}), { __vinextStreamedHtmlResponse: true });
 }
 //#endregion
-export { buildPagesNextDataScript, generatePagesETag, isPagesStreamingBot, renderPagesPageResponse, requestsNoCache };
+export { buildPagesNextDataScript, generatePagesETag, isPagesStreamingBot, renderPagesPageResponse, rendersPagesNotModified };

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

@@ -15,7 +15,7 @@ type PageRouteMatch = {
     dataKind?: PagesRouteDataKind;
   };
 };
-export declare function fetchWorkerFilesystemRoute(request: Request, requestPathname: string, phase: FilesystemRoutePhase, fetchAsset: (request: Request) => Promise<Response>, publicFiles: ReadonlySet<string>, basePath?: string, assetPathPrefix?: string): Promise<Response | false>;
+export declare function fetchWorkerFilesystemRoute(request: Request, requestPathname: string, phase: FilesystemRoutePhase, fetchAsset: (request: Request) => Promise<Response>, publicFiles: ReadonlySet<string>, basePath?: string, assetPathPrefix?: string, hadBasePath?: boolean): Promise<Response | false>;
 export type MiddlewareResult = {
   continue: boolean;
   /** The pathname matches middleware, irrespective of request `has`/`missing` conditions. */
@@ -23,6 +23,8 @@ export type MiddlewareResult = {
   redirectUrl?: string;
   redirectStatus?: number;
   rewriteUrl?: string;
+  /** False when a same-origin rewrite target was outside the basePath. */
+  rewriteHadBasePath?: boolean;
   rewriteStatus?: number;
   status?: number;
   responseHeaders?: Iterable<[string, string]>;
@@ -33,6 +35,8 @@ export type PagesPipelineDeps = {
   assetPrefix?: string;
   basePath: string;
   trailingSlash: boolean;
+  /** next.config `skipTrailingSlashRedirect`: serve both slash forms without a 308. */
+  skipTrailingSlashRedirect?: boolean;
   i18nConfig: NextI18nConfig | null;
   configRedirects: NextRedirect[];
   configRewrites: {
@@ -67,6 +71,7 @@ export type PagesPipelineDeps = {
   matchApiRoute?: ((url: string, request: Request) => PageRouteMatch | null | Promise<PageRouteMatch | null>) | null;
   runMiddleware?: ((request: Request, ctx: unknown, opts: {
     isDataRequest: boolean;
+    isStaleDataRequest?: boolean;
   }) => Promise<MiddlewareResult>) | null;
   /** Original URL presented to middleware when URL normalization is disabled. */
   middlewareRequest?: Request;
@@ -86,10 +91,13 @@ export type PagesPipelineDeps = {
    * Optional filesystem/static-asset probe supplied by each runtime adapter.
    * Called post-middleware (so middleware can intercept/redirect public files) with the
    * resolved basePath-stripped pathname and URL plus the staged middleware response headers.
+   * `request` carries the request headers middleware overrode.
    * Node may write directly to `res` and return true; dev/Workers return a Response.
    * Resolves false to continue through rewrites, API routes, and page rendering.
    */
-  serveFilesystemRoute?: ((requestPathname: string, stagedHeaders: HeaderRecord, phase: FilesystemRoutePhase, resolvedUrl: string) => Promise<boolean | Response>) | null;
+  serveFilesystemRoute?: ((requestPathname: string, stagedHeaders: HeaderRecord, phase: FilesystemRoutePhase, resolvedUrl: string, request: Request,
+  /** Whether the resolved pathname is under the basePath, as Next.js checks before serving filesystem items. */
+  resolvedPathnameHasBasePath: boolean) => Promise<boolean | Response>) | null;
 };
 /**
  * Wrap an adapter's `runMiddleware` callback so middleware receives the original

package/dist/server/pages-request-pipeline.js

@@ -3,16 +3,17 @@ import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { applyMiddlewareRequestHeaders, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
+import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { VINEXT_PRERENDER_REWRITTEN_HEADER } from "./headers.js";
 import { methodNotAllowedResponse, notFoundStaticAssetResponse, sanitizeMethodNotAllowedHeaders } from "./http-error-responses.js";
 import { cloneRequestWithUrl, normalizeTrailingSlash } from "./request-pipeline.js";
-import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
+import { detectPathnameLocale, normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
+import { buildMiddlewarePrefetchSkipResponse } from "./pages-data-route.js";
 import { markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { mergeRewriteQuery } from "../utils/query.js";
-import { buildMiddlewarePrefetchSkipResponse } from "./pages-data-route.js";
 import { setFrameworkRequestRoute } from "./request-tracing.js";
 import { applyConfigHeadersToHeaderRecord } from "./config-headers.js";
 import { finalizeMissingStaticAssetResponse, mergeHeaders } from "./worker-utils.js";
@@ -32,19 +33,23 @@ function headersFromRecord(record) {
 	else headers.set(name, value);
 	return headers;
 }
-async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, basePath = "", assetPathPrefix = "") {
+async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, basePath = "", assetPathPrefix = "", hadBasePath = true) {
 	const isRetrievalMethod = request.method === "GET" || request.method === "HEAD";
-	if (phase === "direct" && isRetrievalMethod || requestPathname === "/api" || requestPathname.startsWith("/api/")) return false;
 	const assetUrl = new URL(request.url);
 	assetUrl.pathname = requestPathname;
 	assetUrl.search = "";
 	const decodedAssetUrl = new URL(assetUrl);
+	let publicFileKey;
 	try {
 		decodedAssetUrl.pathname = decodeURIComponent(assetUrl.pathname);
+		publicFileKey = normalizePathnameForRouteMatchStrict(assetUrl.pathname);
 	} catch {
 		return false;
 	}
-	if (!publicFiles.has(assetUrl.pathname) && !publicFiles.has(decodedAssetUrl.pathname) && !isNextStaticPath(decodedAssetUrl.pathname, basePath, assetPathPrefix)) return false;
+	const isPublicFile = (phase !== "direct" || hadBasePath) && publicFiles.has(publicFileKey);
+	if (!isPublicFile && (requestPathname === "/api" || requestPathname.startsWith("/api/"))) return false;
+	if (phase === "direct" && isRetrievalMethod && !isPublicFile) return false;
+	if (!isPublicFile && !isNextStaticPath(decodedAssetUrl.pathname, basePath, assetPathPrefix)) return false;
 	const response = await fetchAsset(isRetrievalMethod ? new Request(assetUrl, request) : new Request(assetUrl, {
 		method: "HEAD",
 		headers: request.headers
@@ -89,7 +94,7 @@ function wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) {
 * runPagesRequest receives a "clean" request with basePath-stripped URL.
 */
 async function runPagesRequest(request, deps) {
-	const { basePath, trailingSlash, i18nConfig, configRedirects, configRewrites, configHeaders, hadBasePath, isDataReq, isDataRequest } = deps;
+	const { basePath, trailingSlash, skipTrailingSlashRedirect, i18nConfig, configRedirects, configRewrites, configHeaders, hadBasePath, isDataReq, isDataRequest } = deps;
 	const conditionalRedirectCacheability = deps.recordCacheability === false ? void 0 : markConditionalRedirectCacheability;
 	const conditionalRewriteCacheability = deps.recordCacheability === false ? void 0 : markConditionalRewriteCacheability;
 	const proxyExternal = (currentReq, externalUrl) => deps.proxyExternal ? deps.proxyExternal(currentReq, externalUrl) : proxyExternalRequest(currentReq, externalUrl);
@@ -104,7 +109,7 @@ async function runPagesRequest(request, deps) {
 		hadBasePath
 	};
 	{
-		const trailingSlashRedirect = isDataReq ? null : normalizeTrailingSlash(pathname, basePath, trailingSlash, search);
+		const trailingSlashRedirect = isDataReq || skipTrailingSlashRedirect ? null : normalizeTrailingSlash(pathname, hadBasePath ? basePath : "", trailingSlash, search);
 		if (trailingSlashRedirect) return {
 			type: "response",
 			response: trailingSlashRedirect
@@ -117,7 +122,7 @@ async function runPagesRequest(request, deps) {
 		const redirect = matchRedirect(requestConfigMatchPathname, configRedirects, reqCtx, basePathState, conditionalRedirectCacheability);
 		if (redirect) {
 			const dest = sanitizeDestination(basePath && hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, basePath) ? basePath + redirect.destination : redirect.destination);
-			const location = preserveRedirectDestinationQuery(dest, deps.rawSearch ?? search);
+			const location = preserveRedirectDestinationQuery(dest, deps.rawSearch ?? search, redirect.destinationQuery);
 			return {
 				type: "response",
 				response: new Response(null, {
@@ -130,6 +135,11 @@ async function runPagesRequest(request, deps) {
 	const originalResolvedUrl = pathname + search;
 	let resolvedUrl = originalResolvedUrl;
 	let resolvedPathnameIsRequestPathname = true;
+	let resolvedPathnameHasBasePath = hadBasePath;
+	const currentBasePathState = () => ({
+		basePath,
+		hadBasePath: resolvedPathnameHasBasePath
+	});
 	const middlewareHeaders = {};
 	const mergeConfigHeadersIntoEarlyResponse = (response) => {
 		if (configHeaders.length === 0) return response;
@@ -146,10 +156,10 @@ async function runPagesRequest(request, deps) {
 	let middlewareStatus;
 	const serveFilesystemRoute = async (requestPathname, phase) => {
 		if (!deps.serveFilesystemRoute) return null;
-		const served = await deps.serveFilesystemRoute(requestPathname, middlewareHeaders, phase, resolvedUrl);
+		const served = await deps.serveFilesystemRoute(requestPathname, middlewareHeaders, phase, resolvedUrl, request, resolvedPathnameHasBasePath);
 		if (served instanceof Response) {
 			const isStaticMethodNotAllowed = served.status === 405 && served.headers.get("allow") === "GET, HEAD";
-			const response = mergeHeaders(served, middlewareHeaders, isStaticMethodNotAllowed ? void 0 : middlewareStatus);
+			const response = mergeHeaders(served, middlewareHeaders, isStaticMethodNotAllowed || !served.ok || served.status === 206 ? void 0 : middlewareStatus);
 			if (isStaticMethodNotAllowed) sanitizeMethodNotAllowedHeaders(response.headers, "GET, HEAD");
 			return {
 				type: "response",
@@ -159,7 +169,10 @@ async function runPagesRequest(request, deps) {
 		return served ? { type: "handled" } : null;
 	};
 	if (!isOnDemandRevalidate && typeof deps.runMiddleware === "function") {
-		const result = await deps.runMiddleware(deps.middlewareRequest ?? request, deps.ctx ?? null, { isDataRequest });
+		const result = await deps.runMiddleware(deps.middlewareRequest ?? request, deps.ctx ?? null, {
+			isDataRequest,
+			isStaleDataRequest: isDataRequest && !!deps.dataNotFoundResponse
+		});
 		if (deps.recordCacheability !== false && result.pathnameEligible) markRouteCacheabilityDynamic("middleware can match this pathname");
 		if (result.waitUntilPromises && result.waitUntilPromises.length > 0) {
 			const ctx = deps.ctx;
@@ -200,6 +213,7 @@ async function runPagesRequest(request, deps) {
 		if (result.rewriteUrl) {
 			resolvedUrl = result.rewriteUrl;
 			resolvedPathnameIsRequestPathname = false;
+			resolvedPathnameHasBasePath = result.rewriteHadBasePath ?? true;
 		}
 		middlewareStatus = result.status ?? result.rewriteStatus;
 	}
@@ -220,8 +234,8 @@ async function runPagesRequest(request, deps) {
 	const matchedPathnameForRoute = (routePattern) => {
 		const matchedPathname = routePattern ? patternToNextFormat(routePattern) : resolvedPathname;
 		if (!i18nConfig) return matchedPathname;
-		const resolvedLocale = resolvedPathname.split("/", 3)[1];
-		if (resolvedLocale && i18nConfig.locales.includes(resolvedLocale)) return matchedPathname === "/" ? `/${resolvedLocale}` : `/${resolvedLocale}${matchedPathname}`;
+		const resolvedLocale = detectPathnameLocale(resolvedPathname, i18nConfig.locales);
+		if (resolvedLocale) return matchedPathname === "/" ? `/${resolvedLocale}` : `/${resolvedLocale}${matchedPathname}`;
 		return matchResolvedPathname(matchedPathname);
 	};
 	const buildMiddlewarePrefetchSkipResult = (match) => {
@@ -249,7 +263,7 @@ async function runPagesRequest(request, deps) {
 	}
 	let configRewriteFired = false;
 	for (const rewrite of configRewrites.beforeFiles ?? []) {
-		const rewritten = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
+		const rewritten = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), currentBasePathState(), configSourcePathname(), conditionalRewriteCacheability);
 		if (rewritten) {
 			if (isExternalUrl(rewritten)) return {
 				type: "response",
@@ -258,6 +272,7 @@ async function runPagesRequest(request, deps) {
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
 			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 			resolvedPathnameIsRequestPathname = false;
+			resolvedPathnameHasBasePath = !basePath || rewrite.basePath !== false;
 			configRewriteFired = true;
 		}
 	}
@@ -310,7 +325,7 @@ async function runPagesRequest(request, deps) {
 	let pageMatch = !isOutsideBasePathUnclaimed() && deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
 	let resolvedPathnameChanged = false;
 	if (!pageMatch || pageMatch.route.isDynamic) for (const rewrite of configRewrites.afterFiles ?? []) {
-		const rewritten = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
+		const rewritten = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), currentBasePathState(), configSourcePathname(), conditionalRewriteCacheability);
 		if (rewritten) {
 			if (isExternalUrl(rewritten)) return {
 				type: "response",
@@ -319,6 +334,7 @@ async function runPagesRequest(request, deps) {
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
 			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 			resolvedPathnameIsRequestPathname = false;
+			resolvedPathnameHasBasePath = !basePath || rewrite.basePath !== false;
 			configRewriteFired = true;
 			resolvedPathnameChanged = true;
 			const afterFilesFilesystemResult = await serveFilesystemRoute(resolvedPathname, "afterFiles");
@@ -337,7 +353,7 @@ async function runPagesRequest(request, deps) {
 	if (typeof deps.renderPage === "function") {
 		let renderPageMatch = pageMatch;
 		if ((isOutsideBasePathUnclaimed() || isDataReq || isDataRequest) && !renderPageMatch && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
-			const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
+			const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), currentBasePathState(), configSourcePathname(), conditionalRewriteCacheability);
 			if (!fallbackRewrite) continue;
 			if (isExternalUrl(fallbackRewrite)) return {
 				type: "response",
@@ -346,6 +362,7 @@ async function runPagesRequest(request, deps) {
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
 			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 			resolvedPathnameIsRequestPathname = false;
+			resolvedPathnameHasBasePath = !basePath || rewrite.basePath !== false;
 			configRewriteFired = true;
 			const fallbackFilesystemResult = await serveFilesystemRoute(resolvedPathname, "fallback");
 			if (fallbackFilesystemResult) return fallbackFilesystemResult;
@@ -365,7 +382,7 @@ async function runPagesRequest(request, deps) {
 		let response = await deps.renderPage(request, resolvedUrl, initialRenderOptions, stagedHeaders);
 		let matchedFallbackRewrite = false;
 		if (response.status === 404 && shouldDeferErrorPageOnMiss && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
-			const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
+			const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), currentBasePathState(), configSourcePathname(), conditionalRewriteCacheability);
 			if (!fallbackRewrite) continue;
 			if (isExternalUrl(fallbackRewrite)) return {
 				type: "response",
@@ -374,6 +391,7 @@ async function runPagesRequest(request, deps) {
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
 			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 			resolvedPathnameIsRequestPathname = false;
+			resolvedPathnameHasBasePath = !basePath || rewrite.basePath !== false;
 			configRewriteFired = true;
 			const fallbackFilesystemResult = await serveFilesystemRoute(resolvedPathname, "fallback");
 			if (fallbackFilesystemResult) return fallbackFilesystemResult;
@@ -417,7 +435,7 @@ async function runPagesRequest(request, deps) {
 	}
 	let devPageMatch = isOutsideBasePathUnclaimed() ? null : resolvedPathnameChanged ? deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null : pageMatch;
 	if (!devPageMatch && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
-		const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
+		const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), currentBasePathState(), configSourcePathname(), conditionalRewriteCacheability);
 		if (!fallbackRewrite) continue;
 		if (isExternalUrl(fallbackRewrite)) return {
 			type: "response",
@@ -426,6 +444,7 @@ async function runPagesRequest(request, deps) {
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
 		resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 		resolvedPathnameIsRequestPathname = false;
+		resolvedPathnameHasBasePath = !basePath || rewrite.basePath !== false;
 		configRewriteFired = true;
 		const fallbackFilesystemResult = await serveFilesystemRoute(resolvedPathname, "fallback");
 		if (fallbackFilesystemResult) return fallbackFilesystemResult;

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

@@ -16,6 +16,12 @@ export type PagesWorkerExecutionContext = {
 export type PagesLocalResponseStage = (request: Request, env: PagesWorkerEnv | undefined, ctx: ExecutionContextLike, props: WorkerResponseStageProps) => Promise<Response>;
 export declare const pagesRequestStageBuildId: string | null;
 export declare const pagesRequestStagePrerenderSecret: string | null;
+/**
+ * Whether the request stage serves this request as a client build file
+ * outside `_next/static`. Such responses resolve no route, so the Worker
+ * keeps their ASSETS cache policy out of route cacheability admission.
+ */
+export declare function isPagesClientBuildFileRequest(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined): boolean;
 /** Run the request-time stage with a host-owned response dispatcher. */
 export declare function handleRequestStage(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined, dispatchResponseStage: DispatchWorkerResponseStage): Promise<Response>;
 /** Preserve the direct single-entry Worker path without retaining it in request-only builds. */

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

@@ -8,14 +8,17 @@ import { VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_EXPECTED_WORKER_VERSION_H
 import { notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { attachRequestCfMetadata, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname } 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";
 import { applyCdnResponseIdentityHeaders, captureCdnResponsePolicyOverrides, reconcileCdnResponseHeadersAfterOuterPolicy, validateCdnRequest } from "./cache-control.js";
 import { registerLazyDataCacheHandler } from "../shims/cache-handler.js";
-import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath, isImageSourceBodyStatus } from "./image-optimization.js";
 import { traceFrameworkRequest } from "./request-tracing.js";
 import { resolveResponseStageCachePolicy } from "./config-headers.js";
+import { createStaticAssetRequest } from "./worker-utils.js";
 import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
+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";
@@ -39,12 +42,13 @@ function haveSameHeaders(first, second) {
 function captureOuterResponsePolicyHeaders(stagedHeaders, transportedPolicyHeaders) {
 	return captureCdnResponsePolicyOverrides(stagedHeaders, new Headers(transportedPolicyHeaders ?? []));
 }
-const { authorizeOnDemandRevalidate, hasMiddleware, hasRequestAwareDocument, matchApiRoute, matchPageRoute, normalizeDataRequest, publicFiles, runMiddleware, vinextConfig } = pagesEntry;
+const { authorizeOnDemandRevalidate, hasMiddleware, hasRequestAwareDocument, matchApiRoute, matchPageRoute, normalizeDataRequest, publicFiles, clientBuildFiles, runMiddleware, vinextConfig } = pagesEntry;
 const pagesRequestStageBuildId = pagesEntry.buildId ?? null;
 const pagesRequestStagePrerenderSecret = pagesEntry.prerenderSecret ?? null;
 const basePath = vinextConfig?.basePath ?? "";
 const assetPathPrefix = assetPrefixPathname(vinextConfig?.assetPrefix ?? "");
 const trailingSlash = vinextConfig?.trailingSlash ?? false;
+const skipTrailingSlashRedirect = vinextConfig?.skipTrailingSlashRedirect ?? false;
 const i18nConfig = vinextConfig?.i18n ?? null;
 const configRedirects = vinextConfig?.redirects ?? [];
 const configRewrites = vinextConfig?.rewrites ?? {
@@ -60,6 +64,17 @@ const imageConfig = vinextConfig?.images ? {
 	contentDispositionType: vinextConfig.images.contentDispositionType,
 	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
 } : void 0;
+/**
+* Whether the request stage serves this request as a client build file
+* outside `_next/static`. Such responses resolve no route, so the Worker
+* keeps their ASSETS cache policy out of route cacheability admission.
+*/
+function isPagesClientBuildFileRequest(request, env, ctx) {
+	return (request.method === "GET" || request.method === "HEAD") && resolveAssetFetcher(ctx?.assets, env, "worker") !== void 0 && resolveClientBuildFile(new URL(request.url).pathname, basePath, clientBuildFiles) !== null;
+}
+function resolveAssetFetcher(assets, env, defaultHostRuntime) {
+	return assets ?? getExplicitCdnCacheAdapter()?.assets ?? (defaultHostRuntime === "worker" ? env?.ASSETS : void 0);
+}
 /** Run the request-time stage with a host-owned response dispatcher. */
 function handleRequestStage(request, env, ctx, dispatchResponseStage) {
 	const originalRequest = request;
@@ -89,7 +104,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 	let sharedOuterPolicyHeaders = null;
 	let ctx = createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx, dispatchResponseStage, forceCacheBypass, defaultHostRuntime, assets), defaultHostRuntime);
 	configuredCdnCacheAdapters.registerConfiguredCacheAdapters(env);
-	assets ??= getExplicitCdnCacheAdapter()?.assets ?? (defaultHostRuntime === "worker" ? env?.ASSETS : void 0);
+	assets = resolveAssetFetcher(assets, env, defaultHostRuntime);
 	if (configuredCdnCacheAdapters.hasConfiguredDataCache) registerLazyDataCacheHandler(async () => {
 		(await import("virtual:vinext-cache-adapters")).registerConfiguredCacheAdapters(env);
 	});
@@ -143,7 +158,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 				resolvedRoutePathname: pathname
 			},
 			kind: "pages-prerender-discovery",
-			protocolVersion: 4,
+			protocolVersion: 5,
 			requestHost: url.host,
 			stagedHeaders: null
 		}, { cache: "bypass" }, env, ctx);
@@ -154,6 +169,10 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 		} catch {
 			return new Response("Bad Request", { status: 400 });
 		}
+		if (assets && (request.method === "GET" || request.method === "HEAD")) {
+			const clientBuildFile = resolveClientBuildFile(pathname, basePath, clientBuildFiles);
+			if (clientBuildFile) return await assets.fetch(createStaticAssetRequest(clientBuildFile, request));
+		}
 		const missingBuildAsset = isNextStaticPath(pathname, basePath, assetPathPrefix);
 		const hadBasePath = !basePath || hasBasePath(pathname, basePath);
 		{
@@ -189,6 +208,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			assetPrefix: vinextConfig?.assetPrefix,
 			basePath,
 			trailingSlash,
+			skipTrailingSlashRedirect,
 			i18nConfig,
 			configRedirects,
 			configRewrites,
@@ -228,7 +248,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(resolvedUrl, req.url).pathname
 					},
 					kind: "pages-page",
-					protocolVersion: 4,
+					protocolVersion: 5,
 					requestHost: new URL(req.url).host,
 					renderOptions: isDataReq ? {
 						...options,
@@ -268,7 +288,7 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 						resolvedRoutePathname: new URL(apiUrl, req.url).pathname
 					},
 					kind: "pages-api",
-					protocolVersion: 4,
+					protocolVersion: 5,
 					requestHost: new URL(req.url).host,
 					stagedHeaders: [...stagedHeaders]
 				});
@@ -285,17 +305,56 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 					return response;
 				}) : dispatched;
 			},
-			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase, resolvedUrl) => {
+			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase, resolvedUrl, filesystemRequest, resolvedPathnameHasBasePath) => {
 				if (!assets) return false;
-				if (isImageOptimizationPath(requestPathname)) {
+				if (resolvedPathnameHasBasePath && isImageOptimizationPath(requestPathname)) {
 					const imageUrl = new URL(resolvedUrl, request.url);
-					const imageRequest = new Request(imageUrl, request);
+					const imageRequest = cloneRequestWithUrl(request, imageUrl.href);
 					const allowedWidths = [...vinextConfig?.images?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...vinextConfig?.images?.imageSizes ?? DEFAULT_IMAGE_SIZES];
-					return handleConfiguredImageOptimization(imageRequest, (assetPath) => Promise.resolve(assets.fetch(new Request(new URL(assetPath, request.url)))), allowedWidths, imageConfig);
+					const { fetchWorkerImageSource } = await import("./worker-image-optimization.js");
+					return handleConfiguredImageOptimization(imageRequest, (sourceUrl, sourceImageRequest) => fetchWorkerImageSource(sourceUrl, sourceImageRequest, {
+						assets,
+						basePath,
+						assetPathPrefix,
+						clientBuildFiles,
+						fetchPublicFile: (sourceRequest) => resolvePublicImageSource(sourceRequest, assets)
+					}), allowedWidths, imageConfig);
 				}
-				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix);
+				return fetchWorkerFilesystemRoute(filesystemRequest, requestPathname, phase, (assetRequest) => Promise.resolve(assets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, hadBasePath);
 			}
 		};
+		const resolvePublicImageSource = async (sourceRequest, sourceAssets) => {
+			const sourceUrl = new URL(sourceRequest.url);
+			if (guardProtocolRelativeUrl(sourceUrl.pathname, sourceUrl.search)) return null;
+			const sourceHadBasePath = !basePath || hasBasePath(sourceUrl.pathname, basePath);
+			const sourcePathname = stripBasePath(sourceUrl.pathname, basePath);
+			if (isNextDataPathname(sourcePathname)) return null;
+			let sourceAsset = null;
+			const sourceResult = await runPagesRequest(attachRequestCfMetadata(new Request(new URL(sourcePathname + sourceUrl.search, sourceUrl), { signal: sourceRequest.signal }), sourceRequest), {
+				...deps,
+				hadBasePath: sourceHadBasePath,
+				isDataReq: false,
+				isDataRequest: false,
+				middlewareRequest: void 0,
+				dataNotFoundResponse: null,
+				recordCacheability: false,
+				runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, sourceHadBasePath) : null,
+				renderPage: null,
+				handleApi: null,
+				serveFilesystemRoute: async (candidate, _stagedHeaders, phase, _resolvedUrl, filesystemRequest) => {
+					if (isImageOptimizationPath(candidate)) return false;
+					const asset = await fetchWorkerFilesystemRoute(filesystemRequest, candidate, phase, (assetRequest) => Promise.resolve(sourceAssets.fetch(assetRequest)), publicFiles, basePath, assetPathPrefix, sourceHadBasePath);
+					if (asset === false) return false;
+					sourceAsset = asset;
+					return new Response(null);
+				}
+			});
+			if (sourceResult.type !== "response") return null;
+			await sourceResult.response.body?.cancel().catch(() => {});
+			if (isImageSourceBodyStatus(sourceResult.response.status)) return sourceAsset;
+			await sourceAsset?.body?.cancel().catch(() => {});
+			return null;
+		};
 		const result = await runPagesRequest(request, deps);
 		if (result.type === "response") {
 			let response = result.response;
@@ -317,4 +376,4 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 	}
 }
 //#endregion
-export { handleRequestStage, handleRequestStageLocally, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret };
+export { handleRequestStage, handleRequestStageLocally, isPagesClientBuildFileRequest, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret };