vinext 1.4.2 → 1.4.4

package/dist/server/image-source-reader.js

@@ -0,0 +1,126 @@
+//#region src/server/image-source-reader.ts
+/**
+* Streamed reads of an image source for the image optimization endpoint.
+*
+* Animation detection parses a GIF, PNG or WebP source as it streams in rather
+* than buffering it, so a large source cannot exhaust a Worker isolate's
+* memory. Only the source's first bytes are kept, to replay without a refetch.
+*/
+/** Most bytes of a source kept to replay it after animation detection. */
+const HELD_SOURCE_LIMIT = 1048576;
+/** Thrown once a source grows past `images.maximumResponseBody`. */
+var ImageSourceTooLargeError = class extends Error {
+	constructor() {
+		super("Image source exceeds images.maximumResponseBody");
+	}
+};
+var ImageSourceReader = class {
+	#reader;
+	#limit;
+	#read = 0;
+	#done = false;
+	#tooLarge = false;
+	#window = [];
+	#windowStart = 0;
+	#windowEnd = 0;
+	#held = [];
+	#replayed = false;
+	constructor(body, limit) {
+		this.#reader = body.getReader();
+		this.#limit = limit;
+	}
+	/** Whether the source has grown past the limit. */
+	get tooLarge() {
+		return this.#tooLarge;
+	}
+	/** The source's length once it has all been read and held, else null. */
+	get completeLength() {
+		return this.#done && this.#held ? this.#read : null;
+	}
+	/** Stop reading the source without waiting on its cancellation. */
+	cancel() {
+		this.#reader.cancel().catch(() => {});
+	}
+	/** Up to `length` bytes at `offset`, fewer where the source ends. */
+	async bytes(offset, length) {
+		const end = offset + length;
+		await this.#reach(offset, end);
+		const available = Math.min(end, this.#windowEnd);
+		const bytes = new Uint8Array(Math.max(0, available - offset));
+		let start = this.#windowStart;
+		for (const chunk of this.#window) {
+			if (start >= available) break;
+			const from = Math.max(offset - start, 0);
+			const to = Math.min(available - start, chunk.byteLength);
+			if (from < to) bytes.set(chunk.subarray(from, to), start + from - offset);
+			start += chunk.byteLength;
+		}
+		return bytes;
+	}
+	/** The byte at `offset`, or undefined past the source's end. */
+	async byte(offset) {
+		return (await this.bytes(offset, 1))[0];
+	}
+	/**
+	* The whole source as a stream, replaying the bytes already read, or null
+	* once they are no longer all held. An incompletely read source replays
+	* once; the rest streams from the source, still within the limit, and is
+	* held too while the whole source fits.
+	*/
+	body() {
+		const held = this.#held;
+		if (held === null || this.#replayed && !this.#done) return null;
+		this.#replayed = true;
+		this.#window = [];
+		let index = 0;
+		return new ReadableStream({
+			pull: async (controller) => {
+				if (index < held.length) {
+					controller.enqueue(held[index++]);
+					return;
+				}
+				const chunk = await this.#next();
+				if (!chunk) return controller.close();
+				this.#hold(chunk);
+				index = held.length;
+				controller.enqueue(chunk);
+			},
+			cancel: (reason) => this.#reader.cancel(reason)
+		});
+	}
+	async #next() {
+		if (this.#done) return void 0;
+		const { done, value } = await this.#reader.read();
+		if (done) {
+			this.#done = true;
+			return;
+		}
+		this.#read += value.byteLength;
+		if (this.#read > this.#limit) {
+			this.#tooLarge = true;
+			this.cancel();
+			throw new ImageSourceTooLargeError();
+		}
+		return value;
+	}
+	#hold(chunk) {
+		if (!this.#held) return;
+		if (this.#read <= HELD_SOURCE_LIMIT) this.#held.push(chunk);
+		else this.#held = null;
+	}
+	/** Read until `end` is in the window, dropping chunks wholly before `offset`. */
+	async #reach(offset, end) {
+		if (offset < this.#windowStart) throw new Error("Image source reads must not move backwards");
+		for (;;) {
+			while (this.#window.length > 0 && this.#windowStart + this.#window[0].byteLength <= offset) this.#windowStart += this.#window.shift().byteLength;
+			if (this.#windowEnd >= end) return;
+			const chunk = await this.#next();
+			if (!chunk) return;
+			this.#hold(chunk);
+			this.#window.push(chunk);
+			this.#windowEnd += chunk.byteLength;
+		}
+	}
+};
+//#endregion
+export { ImageSourceReader, ImageSourceTooLargeError };

package/dist/server/metadata-route-response.d.ts

@@ -21,6 +21,11 @@ type MetadataRouteRequestOptions = {
   isrRouteKey?: (pathname: string) => string;
   isrSet?: MetadataRouteCacheSetter;
   makeThenableParams: MetadataRouteMakeThenableParams;
+  /**
+   * The pathname params are read from. A direct request passes its raw path
+   * here and its decoded path as `cleanPathname`; a rewrite passes its
+   * destination, still percent-encoded, as both.
+   */
   routePathname?: string;
   scheduleBackgroundRegeneration?: MetadataRouteBackgroundRegenerator;
 };
@@ -36,6 +41,6 @@ export type PrerenderableMetadataRoute = {
  */
 export declare function getPrerenderableMetadataRoutePaths(metadataRoutes: readonly MetadataRuntimeRoute[]): Promise<PrerenderableMetadataRoute[]>;
 export declare function isMetadataRouteRequestPath(metadataRoutes: readonly MetadataRuntimeRoute[], cleanPathname: string): boolean;
-export declare function handleMetadataRouteRequest(options: MetadataRouteRequestOptions): Promise<Response | null>;
+export declare function handleMetadataRouteRequest(requestOptions: MetadataRouteRequestOptions): Promise<Response | null>;
 //#endregion
 export {};

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";
@@ -16,7 +16,7 @@ import { _consumeRequestScopedCacheLife, _isOnDemandRevalidate } from "../shims/
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
 import { isValidMetadataImageId, manifestToJson, matchMetadataRoutePattern, robotsToText, sitemapToXml } from "./metadata-routes.js";
-import { buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
+import { buildAppRouteCacheValue, buildRouteHandlerCachedResponse, stripRouteHandlerFramingHeaders } from "./app-route-handler-response.js";
 import { canonicalizeAppPageParams } from "./app-page-segment-state.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.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);
 }
 /**
@@ -247,7 +261,7 @@ async function renderMetadataRouteMiss(options, route, render, cachedEntry) {
 		const rendered = await render();
 		if (!rendered) return null;
 		await writeMetadataRouteMiss(options, route, rendered, cachedEntry);
-		return rendered.response;
+		return stripRouteHandlerFramingHeaders(rendered.response);
 	};
 	const routeKey = _isOnDemandRevalidate() ? getOuterMetadataCacheKey(options, route) : null;
 	if (routeKey === null || !options.isrSet) return renderAndStore();
@@ -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/navigation-planner.js

@@ -262,11 +262,12 @@ function createFreshFetchDecision(facts, reason) {
 }
 function classifyNavigationReuse(facts) {
 	if (facts.navigationKind === "refresh") return createFreshFetchDecision(facts, "refresh");
-	if (!facts.bypassNavigationCache && facts.visitedResponse.status === "available") return {
+	if (facts.bypassNavigationCache) return createFreshFetchDecision(facts, "cacheBypassed");
+	if (facts.visitedResponse.status === "available") return {
 		kind: "reuseVisitedResponse",
 		trace: createNavigationReuseTrace(NavigationTraceReasonCodes.visitedResponseReuse, facts)
 	};
-	if (!facts.bypassNavigationCache && facts.prefetch.status === "available") return {
+	if (facts.prefetch.status === "available") return {
 		kind: "consumePrefetch",
 		trace: createNavigationReuseTrace(NavigationTraceReasonCodes.prefetchResponseReuse, facts)
 	};
@@ -275,9 +276,8 @@ function classifyNavigationReuse(facts) {
 			kind: "attemptOptimisticRouteShell",
 			trace: createNavigationReuseTrace(NavigationTraceReasonCodes.optimisticRouteShell, facts)
 		};
-		return createFreshFetchDecision(facts, facts.bypassNavigationCache ? "cacheBypassed" : facts.optimisticRouteShell.reason);
+		return createFreshFetchDecision(facts, facts.optimisticRouteShell.reason);
 	}
-	if (facts.bypassNavigationCache) return createFreshFetchDecision(facts, "cacheBypassed");
 	return createFreshFetchDecision(facts, "cacheMiss");
 }
 function classifyNavigationPrefetchProbe(facts) {
@@ -676,10 +676,11 @@ function planFlightResponseArrived(options) {
 		slotBindingSource: "manifestTarget",
 		snapshot: targetSnapshot
 	});
+	const renderedRootLayoutChanged = classifyRootBoundaryTransition(options.state.visibleSnapshot.rootBoundaryId, targetSnapshot.rootBoundaryId) === "rootBoundaryChanged";
 	const traceFields = createRootBoundaryTraceFields({
-		currentRootLayoutTreePath: currentTopology.kind === "known" ? currentTopology.topology.rootLayoutTreePath : null,
+		currentRootLayoutTreePath: renderedRootLayoutChanged ? options.state.visibleSnapshot.rootBoundaryId : currentTopology.kind === "known" ? currentTopology.topology.rootLayoutTreePath : null,
 		event: options.event,
-		nextRootLayoutTreePath: targetTopology.kind === "known" ? targetTopology.topology.rootLayoutTreePath : null,
+		nextRootLayoutTreePath: renderedRootLayoutChanged ? targetSnapshot.rootBoundaryId : targetTopology.kind === "known" ? targetTopology.topology.rootLayoutTreePath : null,
 		state: options.state
 	});
 	if (options.event.token.lane === "prefetch") return {
@@ -708,6 +709,13 @@ function planFlightResponseArrived(options) {
 	}
 	const commitTraceFields = createAcceptedCacheProofTraceFields(traceFields, acceptedCacheEntryDecision);
 	const cacheEntryProposalFields = createCacheEntryProposalFields(acceptedCacheEntryDecision);
+	if (renderedRootLayoutChanged) return {
+		kind: "hardNavigate",
+		reason: "rootBoundaryChanged",
+		token: options.event.token,
+		trace: createNavigationTrace(NavigationTraceReasonCodes.rootBoundaryChanged, commitTraceFields),
+		url: options.event.result.href
+	};
 	if (targetSnapshot.interception !== null) {
 		if (currentTopology.kind === "unknown" || targetTopology.kind === "unknown") return createInterceptionProofRejectedDecision({
 			event: options.event,

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;