vinext 1.4.2 → 1.4.3

package/dist/server/metadata-route-response.js

@@ -2,7 +2,7 @@ import { markFullyBufferedBody } from "./fully-buffered-response.js";
 import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { VINEXT_METADATA_ROUTE_CACHE_HEADER } from "./headers.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { decodeMatchedParams } from "../routing/utils.js";
+import { decodeMatchedParams, normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { beginRouteCacheability, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete, recordRouteCacheability } from "../shims/cacheability-classification.js";
@@ -89,6 +89,20 @@ function getMetadataRouteFunctions(route) {
 	routeFunctionCache.set(route, functions);
 	return functions;
 }
+/**
+* Next.js compiles a metadata route into a Route Handler, and under a dynamic
+* segment its build stores it only when the route's own module generates its
+* params or is `force-static`/`error` (collectAppRouteSegments reads no parent
+* layout). Its metadata loader adds generateStaticParams for
+* generateImageMetadata. Probed on next@16.2.7: a parent layout's
+* generateStaticParams, `revalidate` or `dynamicParams` leave the route
+* dynamic. Generated sitemaps are only served below a static prefix.
+*/
+function isMetadataRouteStaticGenEnabled(route) {
+	if (!route.isDynamic || !route.patternParts) return true;
+	const functions = getMetadataRouteFunctions(route);
+	return route.module?.dynamic === "force-static" || route.module?.dynamic === "error" || functions.generateStaticParams !== null || functions.generateImageMetadata !== null;
+}
 function isUseCacheFunction(value) {
 	return value !== null && Reflect.get(value, USE_CACHE_FUNCTION_SYMBOL) === true;
 }
@@ -165,7 +179,7 @@ async function captureRenderedMetadataRoute(response, route, cleanPathname) {
 		...observedCacheLife,
 		revalidate: frameworkRevalidate
 	};
-	const cacheable = (_isOnDemandRevalidate() || response.status < 400 || response.status === 404) && completed && !isRenderDynamicLatched() && !getActiveDraftModeState() && !hasDraftModeCookieHeader() && route.module?.dynamic !== "force-dynamic" && frameworkRevalidate > 0 && !response.headers.has("set-cookie");
+	const cacheable = (_isOnDemandRevalidate() || response.status < 400 || response.status === 404) && completed && !isRenderDynamicLatched() && !getActiveDraftModeState() && !hasDraftModeCookieHeader() && route.module?.dynamic !== "force-dynamic" && isMetadataRouteStaticGenEnabled(route) && frameworkRevalidate > 0 && !response.headers.has("set-cookie");
 	const cacheControl = cacheable ? buildAppRouteMissIsrCacheControl(frameworkRevalidate, cacheLife?.expire) : NEVER_CACHE_CONTROL;
 	if (isUserResponse && !hasUserPolicy) {
 		response = new Response(response.body, {
@@ -233,7 +247,7 @@ async function runMetadataRouteRegeneration(options, route, render, routeKey, pr
 }
 /** The outer ISR key for a matched metadata route, or null if it's never cached. */
 function getOuterMetadataCacheKey(options, route) {
-	if (!isOuterMetadataCacheEnabled() || !options.isrRouteKey || getActiveDraftModeState() || hasDraftModeCookieHeader() || route.module?.dynamic === "force-dynamic" || route.module?.revalidate === 0) return null;
+	if (!isOuterMetadataCacheEnabled() || !options.isrRouteKey || getActiveDraftModeState() || hasDraftModeCookieHeader() || route.module?.dynamic === "force-dynamic" || route.module?.revalidate === 0 || !isMetadataRouteStaticGenEnabled(route)) return null;
 	return options.isrRouteKey(options.cleanPathname);
 }
 /**
@@ -501,7 +515,11 @@ async function writeMetadataRouteMiss(options, route, rendered, cachedEntry) {
 		console.error("[vinext] Metadata route ISR cache write error:", error);
 	}
 }
-async function handleMetadataRouteRequest(options) {
+async function handleMetadataRouteRequest(requestOptions) {
+	const options = requestOptions.routePathname === requestOptions.cleanPathname ? {
+		...requestOptions,
+		cleanPathname: normalizePathnameForRouteMatch(requestOptions.cleanPathname)
+	} : requestOptions;
 	let urlParts;
 	const getUrlParts = () => urlParts ??= options.cleanPathname.split("/").filter(Boolean);
 	const routePathname = options.routePathname ?? options.cleanPathname;

package/dist/server/middleware-matcher.d.ts

@@ -5,6 +5,7 @@ export type MatcherConfig = string | Array<string | MiddlewareMatcherObject>;
 export type MiddlewareLocaleMatchContext = {
   kind: "defaulted";
   defaultLocale: string;
+  restoreRootTrailingSlash?: boolean;
 } | {
   kind: "internal" | "literal";
 } | {

package/dist/server/middleware-matcher.js

@@ -60,7 +60,7 @@ function matchMatcherPattern(pathname, pattern, i18nConfig, localeContext) {
 function matchObjectMatcher(pathname, matcher, i18nConfig, localeContext) {
 	if (localeContext?.kind === "next-data") return matchNextDataPattern(pathname, matcher.source, i18nConfig, matcher.locale !== false);
 	if (matcher.locale !== false) return matchMatcherPattern(pathname, matcher.source, i18nConfig, localeContext);
-	return matchRequestPattern(localeContext?.kind === "defaulted" ? `/${localeContext.defaultLocale}${pathname === "/" ? "" : pathname}` : pathname, matcher.source);
+	return matchRequestPattern(localeContext?.kind === "defaulted" ? `/${localeContext.defaultLocale}${pathname !== "/" ? pathname : localeContext.restoreRootTrailingSlash ? "/" : ""}` : pathname, matcher.source);
 }
 const APP_ROUTE_TRANSPORT_SUFFIX = "\\.rsc|\\.segments/.+\\.segment\\.rsc";
 const APP_ROUTE_TRANSPORT_SUFFIX_RE = /(?:\.rsc|\.segments\/.+\.segment\.rsc)$/;

package/dist/server/middleware-runtime.d.ts

@@ -61,6 +61,11 @@ type ExecuteMiddlewareOptions = {
    * second tee whose preserved side would never be consumed.
    */
   requestBodyAlreadyIsolated?: boolean;
+  /**
+   * `shouldRestoreLocaleRootTrailingSlash` for the raw request pathname. Next.js
+   * then tests the as-requested root as `/en/` after default-locale insertion.
+   */
+  restoreLocaleRootTrailingSlash?: boolean;
   request: Request;
   /**
    * The user's `trailingSlash` config. Plumbed into the NextRequest's NextURL

package/dist/server/middleware-runtime.js

@@ -69,9 +69,26 @@ function middlewareMatcher(mod) {
 	if (!isMiddlewareConfigExport(config)) return void 0;
 	return config.matcher;
 }
+const MIDDLEWARE_MESSAGE_HEADER_NAMES = [
+	"accept-encoding",
+	"connection",
+	"content-encoding",
+	"content-length",
+	"expect",
+	"keep-alive",
+	"keepalive",
+	"transfer-encoding"
+];
+function deleteMiddlewareMessageHeaders(headers) {
+	for (const name of MIDDLEWARE_MESSAGE_HEADER_NAMES) headers.delete(name);
+}
+function processMiddlewareResponseHeaders(headers) {
+	processMiddlewareHeaders(headers);
+	deleteMiddlewareMessageHeaders(headers);
+}
 function stripMiddlewareHeadersFromResponse(response) {
 	const headers = new Headers(response.headers);
-	processMiddlewareHeaders(headers);
+	processMiddlewareResponseHeaders(headers);
 	return new Response(response.body, {
 		status: response.status,
 		statusText: response.statusText,
@@ -108,7 +125,7 @@ function relativizeLocation(location, requestUrl) {
 */
 function dataRedirectResponse(target, originalResponse) {
 	const headers = new Headers(originalResponse.headers);
-	processMiddlewareHeaders(headers);
+	processMiddlewareResponseHeaders(headers);
 	headers.delete("Location");
 	headers.set("x-nextjs-redirect", target);
 	return new Response(null, {
@@ -120,6 +137,7 @@ function collectMiddlewareHeaders(response) {
 	const responseHeaders = new Headers();
 	for (const [key, value] of response.headers) if (!key.startsWith("x-middleware-") || shouldKeepMiddlewareHeader(key)) responseHeaders.append(key, value);
 	dropEmptyMiddlewareSetCookie(responseHeaders);
+	deleteMiddlewareMessageHeaders(responseHeaders);
 	return responseHeaders;
 }
 function drainFetchEvent(fetchEvent) {
@@ -209,12 +227,19 @@ async function executeMiddlewareModule(options) {
 	};
 	const isStaleDataRequest = options.isDataRequest === true && options.isStaleDataRequest === true;
 	const toPageMatcherPathname = (candidate) => candidate !== null && options.isDataRequest && !isStaleDataRequest ? nextDataMiddlewareMatchPathname(candidate) ?? candidate : candidate;
-	const encodedMatchPathname = toPageMatcherPathname(prepareMatcherPathname(encodedRequestPathname));
-	let decodedMatchPathname = encodedMatchPathname;
-	try {
-		if (encodedMatchPathname !== null) decodedMatchPathname = decodeURIComponent(encodedMatchPathname);
-		else if (!options.i18nConfig) decodedMatchPathname = toPageMatcherPathname(prepareMatcherPathname(decodeURIComponent(encodedRequestPathname)));
-	} catch {}
+	const toMatchPathnames = (candidate) => {
+		const encoded = toPageMatcherPathname(prepareMatcherPathname(candidate));
+		let decoded = encoded;
+		try {
+			if (encoded !== null) decoded = decodeURIComponent(encoded);
+			else if (!options.i18nConfig) decoded = toPageMatcherPathname(prepareMatcherPathname(decodeURIComponent(candidate)));
+		} catch {}
+		return {
+			decoded,
+			encoded
+		};
+	};
+	const { decoded: decodedMatchPathname, encoded: encodedMatchPathname } = toMatchPathnames(encodedRequestPathname);
 	let localeContext;
 	if (isStaleDataRequest) localeContext = { kind: "next-data" };
 	else if (options.i18nConfig && encodedMatchPathname !== null) {
@@ -226,12 +251,20 @@ async function executeMiddlewareModule(options) {
 			kind: "defaulted"
 		};
 	}
-	const encodedPathMatches = encodedMatchPathname !== null && matchesMiddlewarePathname(encodedMatchPathname, matcher, options.i18nConfig, localeContext);
-	const decodedPathMatches = !encodedPathMatches && decodedMatchPathname !== null && decodedMatchPathname !== encodedMatchPathname && matchesMiddlewarePathname(decodedMatchPathname, matcher, options.i18nConfig, localeContext);
-	if (encodedPathMatches || decodedPathMatches) options.onPathMatch?.();
-	const encodedMatches = encodedMatchPathname !== null && matchesMiddleware(encodedMatchPathname, matcher, options.request, options.i18nConfig, localeContext);
-	const decodedMatches = !encodedMatches && decodedMatchPathname !== null && decodedMatchPathname !== encodedMatchPathname && matchesMiddleware(decodedMatchPathname, matcher, options.request, options.i18nConfig, localeContext);
-	if (!encodedMatches && !decodedMatches) return { continue: true };
+	const slashedRequestPathname = normalizePath(requestPathname);
+	const requestedMatchPathnames = slashedRequestPathname !== encodedRequestPathname ? toMatchPathnames(slashedRequestPathname) : {
+		decoded: decodedMatchPathname,
+		encoded: encodedMatchPathname
+	};
+	const candidatePathnames = [];
+	if (requestedMatchPathnames.encoded !== null) candidatePathnames.push(requestedMatchPathnames.encoded);
+	if (requestedMatchPathnames.decoded !== null && requestedMatchPathnames.decoded !== requestedMatchPathnames.encoded) candidatePathnames.push(requestedMatchPathnames.decoded);
+	const requestedLocaleContext = options.restoreLocaleRootTrailingSlash && localeContext?.kind === "defaulted" ? {
+		...localeContext,
+		restoreRootTrailingSlash: true
+	} : localeContext;
+	if (candidatePathnames.some((candidate) => matchesMiddlewarePathname(candidate, matcher, options.i18nConfig, requestedLocaleContext))) options.onPathMatch?.();
+	if (!candidatePathnames.some((candidate) => matchesMiddleware(candidate, matcher, options.request, options.i18nConfig, requestedLocaleContext))) return { continue: true };
 	options.onMatch?.();
 	const middlewareUrl = withOrigin(requestUrl, getRequestExecutionContext()?.middlewareOrigin ?? requestUrl.origin);
 	const nextRequest = createNextRequest(options.request, middlewareUrl, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath, options.requestBodyAlreadyIsolated, options.skipTrailingSlashRedirect);
@@ -305,7 +338,7 @@ async function executeMiddlewareModule(options) {
 			}
 			const responseHeaders = new Headers(response.headers);
 			responseHeaders.delete("location");
-			processMiddlewareHeaders(responseHeaders);
+			processMiddlewareResponseHeaders(responseHeaders);
 			const relativizedResponseHeaders = new Headers(response.headers);
 			relativizedResponseHeaders.set("Location", normalizedLocation);
 			const relativizedResponse = new Response(response.body, {

package/dist/server/middleware.d.ts

@@ -44,6 +44,6 @@ export declare function findMiddlewareFile(root: string, fileMatcher: ValidFileM
  * @param request - The incoming Request object
  * @returns Middleware result describing what action to take
  */
-export declare function runMiddleware(runner: ModuleRunner, middlewarePath: string, request: Request, i18nConfig?: NextI18nConfig | null, basePath?: string, trailingSlash?: boolean, isDataRequest?: boolean, normalizedPathname?: string, isStaleDataRequest?: boolean, skipTrailingSlashRedirect?: boolean): Promise<MiddlewareResult>;
+export declare function runMiddleware(runner: ModuleRunner, middlewarePath: string, request: Request, i18nConfig?: NextI18nConfig | null, basePath?: string, trailingSlash?: boolean, isDataRequest?: boolean, normalizedPathname?: string, isStaleDataRequest?: boolean, skipTrailingSlashRedirect?: boolean, restoreLocaleRootTrailingSlash?: boolean): Promise<MiddlewareResult>;
 //#endregion
 export { matchPattern, matchesMiddleware };

package/dist/server/middleware.js

@@ -77,7 +77,7 @@ function isMiddlewareModule(value) {
 * @param request - The incoming Request object
 * @returns Middleware result describing what action to take
 */
-async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePath, trailingSlash, isDataRequest, normalizedPathname, isStaleDataRequest, skipTrailingSlashRedirect) {
+async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePath, trailingSlash, isDataRequest, normalizedPathname, isStaleDataRequest, skipTrailingSlashRedirect, restoreLocaleRootTrailingSlash) {
 	const mod = await runner.import(middlewarePath);
 	if (!isMiddlewareModule(mod)) throw new Error(`Middleware module "${middlewarePath}" did not evaluate to an object.`);
 	return runGeneratedMiddleware({
@@ -92,6 +92,7 @@ async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePa
 		module: mod,
 		normalizedPathname,
 		request,
+		restoreLocaleRootTrailingSlash,
 		skipTrailingSlashRedirect,
 		trailingSlash
 	});

package/dist/server/nitro-request-target-plugin.d.ts

@@ -0,0 +1,17 @@
+//#region src/server/nitro-request-target-plugin.d.ts
+/**
+ * Nitro runtime plugin that records each request's raw target before h3 sees
+ * it. srvx 0.11 writes the pathname h3 decodes (one with a `%`) back into the
+ * Node request's `url`, dropping the authority of an absolute-form target,
+ * so vinext's request-based entries read the target this plugin saved.
+ *
+ * This module runs in Nitro's server bundle, separate from vinext's request
+ * handlers, so it imports nothing and shares state through `Symbol.for`.
+ */
+export declare const NITRO_REQUEST_TARGET_KEY = "vinext.nitro.requestTarget";
+type NitroApp = {
+  fetch: (request: Request) => Response | Promise<Response>;
+};
+export default function nitroRequestTargetPlugin(nitroApp: NitroApp): void;
+//#endregion
+export {};

package/dist/server/nitro-request-target-plugin.js

@@ -0,0 +1,22 @@
+//#region src/server/nitro-request-target-plugin.ts
+/**
+* Nitro runtime plugin that records each request's raw target before h3 sees
+* it. srvx 0.11 writes the pathname h3 decodes (one with a `%`) back into the
+* Node request's `url`, dropping the authority of an absolute-form target,
+* so vinext's request-based entries read the target this plugin saved.
+*
+* This module runs in Nitro's server bundle, separate from vinext's request
+* handlers, so it imports nothing and shares state through `Symbol.for`.
+*/
+const NITRO_REQUEST_TARGET_KEY = "vinext.nitro.requestTarget";
+function nitroRequestTargetPlugin(nitroApp) {
+	const appFetch = nitroApp.fetch;
+	const key = Symbol.for(NITRO_REQUEST_TARGET_KEY);
+	nitroApp.fetch = (request) => {
+		const req = request.runtime?.node?.req;
+		if (req && !Reflect.has(req, key)) Reflect.set(req, key, req.url);
+		return appFetch(request);
+	};
+}
+//#endregion
+export { NITRO_REQUEST_TARGET_KEY, nitroRequestTargetPlugin as default };

package/dist/server/open-redirect.d.ts

@@ -43,7 +43,8 @@ export type RepeatedSlashRedirect = {
  * `//` after the scheme trips the same check) and 500s `OPTIONS *`. Routing
  * them would let the request line choose the origin of `request.url` that
  * middleware and handlers see, bypassing the Host trust policy. Request-based
- * entries always pass a pathname.
+ * entries pass a pathname. Where srvx builds `request.url` from the raw target
+ * (Nitro's Node server), `isSrvxAbsoluteFormTarget` 404s these instead.
  *
  * @param rawUrl - The raw request target: pathname plus optional `?query`
  */

package/dist/server/open-redirect.js

@@ -44,7 +44,8 @@ const REDIRECT_LOCATION_BASE = "http://vinext.invalid";
 * `//` after the scheme trips the same check) and 500s `OPTIONS *`. Routing
 * them would let the request line choose the origin of `request.url` that
 * middleware and handlers see, bypassing the Host trust policy. Request-based
-* entries always pass a pathname.
+* entries pass a pathname. Where srvx builds `request.url` from the raw target
+* (Nitro's Node server), `isSrvxAbsoluteFormTarget` 404s these instead.
 *
 * @param rawUrl - The raw request target: pathname plus optional `?query`
 */

package/dist/server/pages-client-assets.d.ts

@@ -4,6 +4,7 @@ export type AssetCrossOrigin = "" | "anonymous" | "use-credentials";
 export type PagesClientAssets = {
   clientEntry?: string;
   appBootstrapPreinitModules?: string[];
+  appBootstrapPreloadModules?: string[];
   appRouteManifestModule?: string;
   /** What each App Router client reference loads in the browser, by URL. */
   appClientReferenceChunks?: ClientReferenceChunks;

package/dist/server/pages-i18n.d.ts

@@ -24,6 +24,13 @@ type PagesI18nRequestInfo = {
   domainLocale?: DomainLocale;
   redirectUrl?: string;
 };
+/**
+ * Mark a locale-detection redirect. Next.js answers it before next.config
+ * headers are staged, so it goes out without them. The global symbol crosses
+ * the App Router / Pages Router module graph boundary.
+ */
+export declare function markLocaleRedirect(response: Response): Response;
+export declare function isLocaleRedirect(response: Response): boolean;
 /**
  * Return the configured locale that the first pathname segment names, compared
  * case-insensitively (`/EN/about` -> `"en"`), or `undefined` when there is none.

package/dist/server/pages-i18n.js

@@ -8,6 +8,19 @@ function readHeader(headers, name) {
 	return direct;
 }
 const normalizeHostname = normalizeDomainHostname;
+const LOCALE_REDIRECT = Symbol.for("vinext.pages-locale-redirect");
+/**
+* Mark a locale-detection redirect. Next.js answers it before next.config
+* headers are staged, so it goes out without them. The global symbol crosses
+* the App Router / Pages Router module graph boundary.
+*/
+function markLocaleRedirect(response) {
+	if (!isLocaleRedirect(response)) Object.defineProperty(response, LOCALE_REDIRECT, { value: true });
+	return response;
+}
+function isLocaleRedirect(response) {
+	return LOCALE_REDIRECT in response;
+}
 /**
 * Return the configured locale that the first pathname segment names, compared
 * case-insensitively (`/EN/about` -> `"en"`), or `undefined` when there is none.
@@ -259,4 +272,4 @@ function resolvePagesI18nRequest(url, i18nConfig, headers, hostname, basePath =
 	};
 }
 //#endregion
-export { detectDomainLocale, detectLocaleFromAcceptLanguage, detectPathnameLocale, extractLocaleFromUrl, getLocaleRedirect, normalizeDefaultLocalePathname, parseCookieLocaleFromHeader, resolvePagesI18nRequest, shouldRestoreLocaleRootTrailingSlash, stripI18nLocaleForApiRoute };
+export { detectDomainLocale, detectLocaleFromAcceptLanguage, detectPathnameLocale, extractLocaleFromUrl, getLocaleRedirect, isLocaleRedirect, markLocaleRedirect, normalizeDefaultLocalePathname, parseCookieLocaleFromHeader, resolvePagesI18nRequest, shouldRestoreLocaleRootTrailingSlash, stripI18nLocaleForApiRoute };

package/dist/server/pages-node-compat.js

@@ -201,10 +201,14 @@ var PagesResponseStream = class extends Writable {
 		return this;
 	}
 	json(data) {
-		this.resHeaders["content-type"] = "application/json";
+		this.resHeaders["content-type"] = "application/json; charset=utf-8";
 		this.end(JSON.stringify(data));
 	}
 	send(data) {
+		if (data === null || data === void 0) {
+			this.end();
+			return;
+		}
 		if (NO_BODY_RESPONSE_STATUSES.has(this.resStatusCode)) {
 			this.end();
 			return;
@@ -220,8 +224,8 @@ var PagesResponseStream = class extends Writable {
 			this.end(data);
 			return;
 		}
-		if (typeof data === "object" && data !== null) {
-			this.resHeaders["content-type"] = "application/json";
+		if (typeof data === "object" || typeof data === "number" || typeof data === "boolean") {
+			this.resHeaders["content-type"] = "application/json; charset=utf-8";
 			this.end(JSON.stringify(data));
 			return;
 		}

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

@@ -5,7 +5,7 @@ import { NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, VINEXT_CACHE_HEADER,
 import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { extractLocaleFromUrl, resolvePagesI18nRequest } from "./pages-i18n.js";
+import { extractLocaleFromUrl, markLocaleRedirect, resolvePagesI18nRequest } from "./pages-i18n.js";
 import { buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, normalizePagesDataRequest, parseNextDataPathname } from "./pages-data-route.js";
 import { reportRequestError } from "./instrumentation.js";
 import { logRequestError } from "./request-error-log.js";
@@ -154,7 +154,7 @@ function createPagesPageHandler(opts) {
 		const originalRequestPathAndSearch = originalRequestUrl.pathname + originalRequestUrl.search;
 		let dataRequestPathname = null;
 		let dataRequestSearch = "";
-		const initialDataNorm = normalizePagesDataRequest(request, buildId, vinextConfig.basePath, hasMiddleware && vinextConfig.trailingSlash);
+		const initialDataNorm = normalizePagesDataRequest(request, buildId, "", hasMiddleware && vinextConfig.trailingSlash);
 		if (!isDataReq) {
 			if (initialDataNorm.notFoundResponse) return initialDataNorm.notFoundResponse;
 			if (initialDataNorm.isDataReq) {
@@ -195,10 +195,10 @@ function createPagesPageHandler(opts) {
 		const currentDefaultLocale = i18nConfig ? localeInfo.domainLocale ? localeInfo.domainLocale.defaultLocale : i18nConfig.defaultLocale : void 0;
 		const domainLocales = i18nConfig ? i18nConfig.domains : void 0;
 		const pageIsrCacheKey = isrCacheKeyForRequest(i18nConfig ? localeInfo.domainLocale ? JSON.stringify([String(localeInfo.domainLocale.domain).toLowerCase(), locale]) : "locale:" + String(locale) : null);
-		if (localeInfo.redirectUrl) return new Response(null, {
+		if (localeInfo.redirectUrl) return markLocaleRedirect(new Response(null, {
 			status: 307,
 			headers: { Location: localeInfo.redirectUrl }
-		});
+		}));
 		let match = options && options.__forcedRoute ? {
 			route: options.__forcedRoute,
 			params: {}

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

@@ -15,6 +15,14 @@ type PageRouteMatch = {
     dataKind?: PagesRouteDataKind;
   };
 };
+/**
+ * Whether a filesystem route may serve `requestPathname` from the client
+ * build directory. Like Next.js, only a public file or a build asset resolves
+ * there: the directory also holds build metadata and private artifacts. A
+ * direct GET/HEAD reaches this route only for a public file, since servers
+ * answer existing build assets before middleware.
+ */
+export declare function isServableFilesystemRoute(requestPathname: string, phase: FilesystemRoutePhase, method: string, publicFiles: ReadonlySet<string>, basePath?: string, assetPathPrefix?: string, pathnameHasBasePath?: boolean): boolean;
 export declare function fetchWorkerFilesystemRoute(request: Request, requestPathname: string, phase: FilesystemRoutePhase, fetchAsset: (request: Request) => Promise<Response>, publicFiles: ReadonlySet<string>, basePath?: string, assetPathPrefix?: string, pathnameHasBasePath?: boolean): Promise<Response | false>;
 export type MiddlewareResult = {
   continue: boolean;
@@ -77,6 +85,7 @@ export type PagesPipelineDeps = {
   runMiddleware?: ((request: Request, ctx: unknown, opts: {
     isDataRequest: boolean;
     isStaleDataRequest?: boolean;
+    restoreLocaleRootTrailingSlash?: boolean;
   }) => Promise<MiddlewareResult>) | null;
   /** Original URL presented to middleware when URL normalization is disabled. */
   middlewareRequest?: Request;

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

@@ -19,6 +19,7 @@ import { setFrameworkRequestRoute } from "./request-tracing.js";
 import { withExternalRewriteResponseHeaders } from "./middleware-response-headers.js";
 import { applyConfigHeadersToHeaderRecord } from "./config-headers.js";
 import { finalizeMissingStaticAssetResponse, mergeHeaders, mergeStaticFileHeaders } from "./worker-utils.js";
+import { publicFileRouteKey } from "../utils/public-file-path.js";
 //#region src/server/pages-request-pipeline.ts
 function ruleUsesUnkeyedRequestCondition(rule) {
 	return [...rule.has ?? [], ...rule.missing ?? []].some((condition) => condition.type === "header" || condition.type === "cookie" || condition.type === "host");
@@ -35,24 +36,41 @@ function headersFromRecord(record) {
 	else headers.set(name, value);
 	return headers;
 }
-async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, basePath = "", assetPathPrefix = "", pathnameHasBasePath = true) {
-	const isRetrievalMethod = request.method === "GET" || request.method === "HEAD";
-	const assetUrl = new URL(request.url);
+/**
+* Whether a filesystem route may serve `requestPathname` from the client
+* build directory. Like Next.js, only a public file or a build asset resolves
+* there: the directory also holds build metadata and private artifacts. A
+* direct GET/HEAD reaches this route only for a public file, since servers
+* answer existing build assets before middleware.
+*/
+function isServableFilesystemRoute(requestPathname, phase, method, publicFiles, basePath = "", assetPathPrefix = "", pathnameHasBasePath = true) {
+	const assetUrl = new URL("http://localhost");
 	assetUrl.pathname = requestPathname;
-	assetUrl.search = "";
 	const decodedAssetUrl = new URL(assetUrl);
 	let publicFileKey;
+	let servedPathname;
+	let servedFileKey;
 	try {
 		decodedAssetUrl.pathname = decodeURIComponent(assetUrl.pathname);
 		publicFileKey = normalizePathnameForRouteMatchStrict(assetUrl.pathname);
+		servedPathname = decodeURIComponent(requestPathname);
+		servedFileKey = publicFileRouteKey(servedPathname);
 	} catch {
 		return false;
 	}
-	if (!pathnameHasBasePath && !isAssetPrefixBuildAsset(decodedAssetUrl.pathname, assetPathPrefix)) return false;
-	const isPublicFile = pathnameHasBasePath && publicFiles.has(publicFileKey);
+	const decodedPathname = decodedAssetUrl.pathname;
+	if (!pathnameHasBasePath && !isAssetPrefixBuildAsset(decodedPathname, assetPathPrefix)) return false;
+	const isPublicFile = pathnameHasBasePath && publicFiles.has(publicFileKey) && publicFiles.has(servedFileKey);
 	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;
+	if (phase === "direct" && (method === "GET" || method === "HEAD") && !isPublicFile) return false;
+	return isPublicFile || isNextStaticPath(decodedPathname, basePath, assetPathPrefix) && isNextStaticPath(servedPathname, basePath, assetPathPrefix);
+}
+async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, basePath = "", assetPathPrefix = "", pathnameHasBasePath = true) {
+	const isRetrievalMethod = request.method === "GET" || request.method === "HEAD";
+	const assetUrl = new URL(request.url);
+	assetUrl.pathname = requestPathname;
+	assetUrl.search = "";
+	if (!isServableFilesystemRoute(requestPathname, phase, request.method, publicFiles, basePath, assetPathPrefix, pathnameHasBasePath)) return false;
 	const response = await fetchAsset(isRetrievalMethod ? new Request(assetUrl, request) : new Request(assetUrl, {
 		method: "HEAD",
 		headers: request.headers
@@ -179,7 +197,8 @@ async function runPagesRequest(request, deps) {
 	if (!isOnDemandRevalidate && typeof deps.runMiddleware === "function") {
 		const result = await deps.runMiddleware(deps.middlewareRequest ?? request, deps.ctx ?? null, {
 			isDataRequest,
-			isStaleDataRequest: isDataRequest && !!deps.dataNotFoundResponse
+			isStaleDataRequest: isDataRequest && !!deps.dataNotFoundResponse,
+			restoreLocaleRootTrailingSlash: deps.restoreLocaleRootTrailingSlash
 		});
 		if (deps.recordCacheability !== false && result.pathnameEligible) markRouteCacheabilityDynamic("middleware can match this pathname");
 		if (result.waitUntilPromises && result.waitUntilPromises.length > 0) {
@@ -465,4 +484,4 @@ async function runPagesRequest(request, deps) {
 	};
 }
 //#endregion
-export { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath };
+export { fetchWorkerFilesystemRoute, isServableFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath };

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

@@ -73,7 +73,9 @@ const imageConfig = vinextConfig?.images ? {
 	dangerouslyAllowSVG: vinextConfig.images.dangerouslyAllowSVG,
 	dangerouslyAllowLocalIP: vinextConfig.images.dangerouslyAllowLocalIP,
 	contentDispositionType: vinextConfig.images.contentDispositionType,
-	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
+	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy,
+	minimumCacheTTL: vinextConfig.images.minimumCacheTTL,
+	maximumResponseBody: vinextConfig.images.maximumResponseBody
 } : void 0;
 /**
 * Whether the request stage serves this request as a client build file
@@ -384,7 +386,10 @@ async function handleRequestImpl(request, env, platformCtx, dispatchResponseStag
 			});
 			if (sourceResult.type !== "response") return null;
 			await sourceResult.response.body?.cancel().catch(() => {});
-			if (isImageSourceBodyStatus(sourceResult.response.status)) return sourceAsset;
+			if (isImageSourceBodyStatus(sourceResult.response.status) && sourceAsset !== null) {
+				const { withStagedCacheControl } = await import("./worker-image-optimization.js");
+				return withStagedCacheControl(sourceAsset, sourceResult.response.headers.get("Cache-Control"));
+			}
 			await sourceAsset?.body?.cancel().catch(() => {});
 			return null;
 		};

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

@@ -1,10 +1,12 @@
 import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM } from "./headers.js";
+import { notFoundResponse } from "./http-error-responses.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";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
+import { isSrvxAbsoluteFormTarget } from "./srvx-request-target.js";
 import { handleRequestStageLocally, isPagesClientBuildFileRequest, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret } from "./pages-request-stage-entry.js";
 import { renderPagesResponse } from "./pages-response-stage-entry.js";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
@@ -52,6 +54,7 @@ async function handleSingleStageRequest(request, env, platformCtx) {
 	return finalize ? finalize(response, ctx) : response;
 }
 var pages_router_entry_default = { fetch(request, env, ctx) {
+	if (isSrvxAbsoluteFormTarget(request)) return Promise.resolve(notFoundResponse());
 	const strippedRequest = stripRequestUrlFragment(request);
 	const handle = () => handleSingleStageRequest(strippedRequest, env, ctx);
 	return ctx && typeof ctx.waitUntil === "function" ? runWithExecutionContext(ctx, handle) : handle();

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

@@ -90,7 +90,7 @@ declare function mergeWebResponse(middlewareHeaders: Record<string, string | str
  * Send a compressed response if the content type is compressible and the
  * client supports compression. Otherwise send uncompressed.
  */
-declare function sendCompressed(req: IncomingMessage, res: ServerResponse, body: string | Buffer, contentType: string, statusCode: number, extraHeaders?: Record<string, string | string[]>, compress?: boolean, statusText?: string): void;
+declare function sendCompressed(req: IncomingMessage, res: ServerResponse, body: string | Buffer, contentType: string | undefined, statusCode: number, extraHeaders?: Record<string, string | string[]>, compress?: boolean, statusText?: string): void;
 /**
  * Try to serve a static file from the client build directory.
  *