vinext 1.2.1 → 1.3.1

package/dist/server/middleware-response-headers.js

@@ -42,5 +42,61 @@ function mergeMiddlewareResponseHeaders(target, middlewareHeaders) {
 		target.set(key, value);
 	}
 }
+const RESPONSE_APPENDED_HEADER_NAMES = [
+	"set-cookie",
+	"www-authenticate",
+	"proxy-authenticate"
+];
+const RESPONSE_APPENDED_COOKIE_HEADER_NAMES = ["set-cookie"];
+/**
+* Merge middleware response headers onto an already-built response's headers.
+*
+* Next.js writes middleware response headers before the handler runs and then
+* appends the handler response's Set-Cookie, WWW-Authenticate and
+* Proxy-Authenticate values, so middleware values come first and the
+* response's own are kept. A handler's cookie for the same name (a logout
+* deletion or session rotation) is then the one the browser applies last.
+*/
+function mergeMiddlewareResponseHeadersOntoResponse(target, middlewareHeaders, options = {}) {
+	if (!middlewareHeaders) return;
+	const responseValues = [];
+	const appendedNames = options.appendResponseChallenges === false ? RESPONSE_APPENDED_COOKIE_HEADER_NAMES : RESPONSE_APPENDED_HEADER_NAMES;
+	for (const name of appendedNames) {
+		if (!middlewareHeaders.has(name)) continue;
+		const value = target.get(name);
+		responseValues.push([name, name === "set-cookie" ? target.getSetCookie() : value === null ? [] : [value]]);
+		target.delete(name);
+	}
+	mergeMiddlewareResponseHeaders(target, middlewareHeaders);
+	for (const [name, values] of responseValues) {
+		if (!middlewareHeaders.get(name)) target.delete(name);
+		for (const value of values) target.append(name, value);
+	}
+}
+/**
+* Build the response for an external rewrite from the headers routing staged
+* before proxying.
+*
+* Next.js writes the staged config and middleware headers to its outgoing
+* response and then proxies, and the proxy sets each upstream header over
+* them. Its Set-Cookie patch keeps middleware's cookies ahead of the
+* upstream's, so an upstream cookie replaces a staged config cookie while
+* middleware's are kept. Without an upstream Set-Cookie the staged cookies
+* stay as they are.
+*/
+function withExternalRewriteResponseHeaders(upstream, staged, middlewareCookies) {
+	staged.delete("content-length");
+	for (const name of new Set(upstream.headers.keys())) if (name !== "set-cookie") staged.set(name, upstream.headers.get(name) ?? "");
+	const upstreamCookies = upstream.headers.getSetCookie();
+	if (upstreamCookies.length > 0) {
+		staged.delete("set-cookie");
+		for (const cookie of /* @__PURE__ */ new Set([...middlewareCookies, ...upstreamCookies])) staged.append("set-cookie", cookie);
+	}
+	return new Response(upstream.body, {
+		status: upstream.status,
+		statusText: upstream.statusText,
+		headers: staged
+	});
+}
 //#endregion
-export { mergeMiddlewareResponseHeaders, mergeVaryHeader };
+export { mergeMiddlewareResponseHeaders, mergeMiddlewareResponseHeadersOntoResponse, mergeVaryHeader, withExternalRewriteResponseHeaders };

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

@@ -87,4 +87,5 @@ export declare function resolveMiddlewareModuleHandler(mod: MiddlewareModule, op
 }): MiddlewareHandler;
 export declare function executeMiddleware(options: ExecuteMiddlewareOptions): Promise<MiddlewareResult>;
 export declare function runGeneratedMiddleware(options: RunGeneratedMiddlewareOptions): Promise<MiddlewareResult>;
-//#endregion
+//#endregion
+export {};

package/dist/server/middleware-runtime.js

@@ -6,7 +6,7 @@ import { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath
 import { MIDDLEWARE_REWRITE_HEADER } from "./headers.js";
 import { badRequestResponse, internalServerErrorResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
-import { processMiddlewareHeaders } from "./request-pipeline.js";
+import { dropEmptyMiddlewareSetCookie, processMiddlewareHeaders } from "./request-pipeline.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
 import "./server-globals.js";
@@ -118,6 +118,7 @@ function dataRedirectResponse(target, originalResponse) {
 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);
 	return responseHeaders;
 }
 function drainFetchEvent(fetchEvent) {
@@ -135,12 +136,19 @@ function resolveMiddlewarePathname(request) {
 		return badRequestResponse();
 	}
 }
-function createNextRequest(request, i18nConfig, basePath, trailingSlash, hadBasePath, requestBodyAlreadyIsolated = false, skipTrailingSlashRedirect = false) {
-	const url = new URL(request.url);
+/** The same path and query on another origin. */
+function withOrigin(url, origin) {
+	const result = new URL(origin);
+	if (result.origin === url.origin) return url;
+	result.pathname = url.pathname;
+	result.search = url.search;
+	return result;
+}
+function createNextRequest(request, url, i18nConfig, basePath, trailingSlash, hadBasePath, requestBodyAlreadyIsolated = false, skipTrailingSlashRedirect = false) {
 	let mwRequest = !requestBodyAlreadyIsolated && request.body && !request.bodyUsed ? request.clone() : request;
 	const requestPathname = url.pathname;
 	const mwPathname = basePath && hadBasePath && !hasBasePath(requestPathname, basePath) ? addBasePathToPathname(requestPathname, basePath) : requestPathname;
-	if (mwPathname !== url.pathname) {
+	if (mwPathname !== url.pathname || url.href !== request.url) {
 		const mwUrl = new URL(url);
 		mwUrl.pathname = mwPathname;
 		mwRequest = new Request(mwUrl, mwRequest);
@@ -151,7 +159,12 @@ function createNextRequest(request, i18nConfig, basePath, trailingSlash, hadBase
 		trailingSlash: trailingSlash ?? void 0,
 		skipTrailingSlashRedirect
 	} : void 0;
-	const nextRequest = mwRequest instanceof NextRequest && (!mwRequest.body || mwRequest.bodyUsed) ? mwRequest : new NextRequest(mwRequest, nextConfig ? { nextConfig } : void 0);
+	const requestUrl = new URL(request.url);
+	const requestHost = requestUrl.origin === url.origin ? void 0 : requestUrl.host;
+	const nextRequest = mwRequest instanceof NextRequest && (!mwRequest.body || mwRequest.bodyUsed) ? mwRequest : new NextRequest(mwRequest, nextConfig ? {
+		nextConfig,
+		requestHost
+	} : void 0);
 	if (mwRequest !== request && mwRequest.body && !mwRequest.bodyUsed && !mwRequest.body.locked) mwRequest.body.cancel().catch(() => {});
 	return nextRequest;
 }
@@ -219,7 +232,8 @@ async function executeMiddlewareModule(options) {
 	const decodedMatches = !encodedMatches && decodedMatchPathname !== null && decodedMatchPathname !== encodedMatchPathname && matchesMiddleware(decodedMatchPathname, matcher, options.request, options.i18nConfig, localeContext);
 	if (!encodedMatches && !decodedMatches) return { continue: true };
 	options.onMatch?.();
-	const nextRequest = createNextRequest(options.request, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath, options.requestBodyAlreadyIsolated, options.skipTrailingSlashRedirect);
+	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);
 	if (options.isDataRequest) Object.defineProperty(nextRequest, "__isData", {
 		enumerable: false,
 		value: true
@@ -260,11 +274,11 @@ async function executeMiddlewareModule(options) {
 	if (response.status >= 300 && response.status < 400) {
 		const location = response.headers.get("Location") ?? response.headers.get("location");
 		if (location) {
-			const relativeLocation = relativizeLocation(location, options.request.url);
+			const relativeLocation = relativizeLocation(location, middlewareUrl.href);
 			let normalizedLocation = relativeLocation;
 			if (options.trailingSlash !== void 0 && !options.skipTrailingSlashRedirect) try {
-				const loc = new URL(relativeLocation, options.request.url);
-				if (loc.origin === new URL(options.request.url).origin) {
+				const loc = new URL(relativeLocation, middlewareUrl);
+				if (loc.origin === middlewareUrl.origin) {
 					const p = loc.pathname;
 					let normalized = null;
 					if (p !== "" && p !== "/") {
@@ -273,7 +287,7 @@ async function executeMiddlewareModule(options) {
 					}
 					if (normalized !== null) {
 						loc.pathname = normalized;
-						normalizedLocation = relativizeLocation(loc.toString(), options.request.url);
+						normalizedLocation = relativizeLocation(loc.toString(), middlewareUrl.href);
 					}
 				}
 			} catch {}
@@ -311,9 +325,8 @@ async function executeMiddlewareModule(options) {
 		let rewritePath;
 		let rewriteHadBasePath;
 		try {
-			const rewriteParsed = new URL(rewriteUrl, options.request.url);
-			const requestOrigin = new URL(options.request.url).origin;
-			if (rewriteParsed.origin === requestOrigin) {
+			const rewriteParsed = new URL(rewriteUrl, middlewareUrl);
+			if (rewriteParsed.origin === middlewareUrl.origin) {
 				rewriteHadBasePath = !options.basePath || hasBasePath(rewriteParsed.pathname, options.basePath);
 				rewritePath = (options.basePath ? stripBasePath(rewriteParsed.pathname, options.basePath) : rewriteParsed.pathname) + rewriteParsed.search;
 			} else rewritePath = rewriteParsed.href;

package/dist/server/navigation-planner.d.ts

@@ -1,4 +1,4 @@
-import { RouteManifest } from "../routing/app-route-graph.js";
+import { BrowserRouteManifest } from "../routing/browser-route-manifest.js";
 import { CacheEntryReuseDecision, CacheEntryReuseProof } from "./cache-proof.js";
 import { AppElementsSlotBinding } from "./app-elements-wire.js";
 import "./app-elements.js";
@@ -230,7 +230,7 @@ type NavigationPrefetchProbeDecision = {
   reason: "cacheBypassed" | "refresh" | "visitedResponseAvailable";
 };
 export type NavigationPlannerInput = {
-  routeManifest: RouteManifest | null;
+  routeManifest: BrowserRouteManifest | null;
   state: NavigationPlannerState;
   event: NavigationEvent;
 };

package/dist/server/navigation-trace.d.ts

@@ -65,4 +65,5 @@ export declare function createNavigationLifecycleTraceFields(options: {
 }): NavigationTraceFields;
 export declare function createNavigationTrace(code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
 export declare function prependNavigationTraceEntry(trace: NavigationTrace, code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
-//#endregion
+//#endregion
+export {};

package/dist/server/next-error-digest.d.ts

@@ -24,4 +24,5 @@ export declare function parseNextRedirectDigest(digest: string): NextRedirectDig
  * for the fallback form. Returns null otherwise.
  */
 export declare function parseNextHttpErrorDigest(digest: string): NextHttpErrorDigest | null;
-//#endregion
+//#endregion
+export {};

package/dist/server/nitro-public-files-plugin.d.ts

@@ -0,0 +1,39 @@
+//#region src/server/nitro-public-files-plugin.d.ts
+/**
+ * Nitro runtime plugin that lets vinext serve the files in `public/`.
+ *
+ * Nitro's static handler answers a request for a public file before any app
+ * handler runs, so middleware would never see it. The plugin sends those
+ * requests to vinext instead. vinext's router then decides which public file
+ * a request resolves to, for example the destination of a rewrite, but only
+ * the static handler can read the file from the server output. The plugin
+ * publishes an asset fetcher that sends a request back through the Nitro app,
+ * where the static handler answers it.
+ *
+ * This module runs in Nitro's server bundle, separate from vinext's request
+ * handlers, so it imports nothing and shares state through `globalThis`.
+ */
+export declare const NITRO_ASSETS_KEY = "vinext.nitro.assets";
+type NitroApp = {
+  fetch: (request: Request) => Response | Promise<Response>;
+  captureError?: (error: unknown, context: {
+    tags?: string[];
+  }) => void;
+};
+export type NitroAssets = {
+  fetch(request: Request): Promise<Response>;
+  /** Whether a request is an asset fetch that Nitro's static handler did not answer. */
+  isAssetRequest(request: Request): boolean;
+};
+type NitroPublicFilesPluginOptions = {
+  /**
+   * The static files Nitro serves for the files in `public/`, including
+   * their compressed copies, keyed as Nitro's static handler keys them.
+   */
+  publicAssets: string[];
+  /** Sends a request to vinext's request handler. */
+  fetchApp(request: Request): Promise<Response>;
+};
+export declare function createNitroPublicFilesPlugin(options: NitroPublicFilesPluginOptions): (nitroApp: NitroApp) => void;
+//#endregion
+export {};

package/dist/server/nitro-public-files-plugin.js

@@ -0,0 +1,106 @@
+//#region src/server/nitro-public-files-plugin.ts
+/**
+* Nitro runtime plugin that lets vinext serve the files in `public/`.
+*
+* Nitro's static handler answers a request for a public file before any app
+* handler runs, so middleware would never see it. The plugin sends those
+* requests to vinext instead. vinext's router then decides which public file
+* a request resolves to, for example the destination of a rewrite, but only
+* the static handler can read the file from the server output. The plugin
+* publishes an asset fetcher that sends a request back through the Nitro app,
+* where the static handler answers it.
+*
+* This module runs in Nitro's server bundle, separate from vinext's request
+* handlers, so it imports nothing and shares state through `globalThis`.
+*/
+const NITRO_ASSETS_KEY = "vinext.nitro.assets";
+const ASSET_REQUEST_HEADER = "x-vinext-nitro-asset";
+const STATIC_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+const ENCODING_EXTENSIONS = /* @__PURE__ */ new Map([
+	["br", ".br"],
+	["gzip", ".gz"],
+	["zstd", ".zst"]
+]);
+/**
+* The pathnames h3 can give Nitro's static handler for a request URL. srvx
+* usually hands h3 the URL's path up to the query as it is, so a literal `#`
+* stays in it, but parses the URL fully when the path needs normalizing.
+*/
+function getRequestPathnames(url) {
+	const parsed = new URL(url).pathname;
+	const start = url.indexOf("/", url.indexOf("://") + 3);
+	if (start === -1) return [parsed];
+	const query = url.indexOf("?", start);
+	const raw = url.slice(start, query === -1 ? void 0 : query);
+	return raw === parsed ? [parsed] : [parsed, raw];
+}
+/**
+* The pathname h3 2.0.1-rc.22, which the pinned Nitro uses, gives Nitro's
+* static handler. When it creates the request event, it decodes a pathname
+* that contains `%` except for `%25`, and the URL parser then resolves the
+* result again, for example `\` and `..` segments. Returns `undefined` when
+* h3 fails the request instead. Newer h3 releases leave decoding to Nitro, so
+* the plugin also looks up the pathname without this step.
+*/
+function toH3Pathname(pathname) {
+	if (!pathname.includes("%")) return pathname;
+	try {
+		const url = new URL("http://localhost");
+		url.pathname = decodeURI(pathname.replace(/%25/g, "%2525"));
+		return url.pathname;
+	} catch {
+		return;
+	}
+}
+/**
+* Whether Nitro's static handler would answer a request for a pathname with
+* a public file, following its lookup in `runtime/internal/static.mjs`. It
+* looks h3's pathname up without one trailing slash and decoded except for
+* `%2F`, and then as a directory with an `index.html`, each first with the
+* extension of a compressed copy for every encoding the request accepts.
+*/
+function isPublicFilePathname(pathname, extensions, publicAssets) {
+	let id = pathname.length > 1 && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+	try {
+		id = decodeURIComponent(id.replace(/%2f/gi, "%252F"));
+	} catch {}
+	const index = id.endsWith("/") ? `${id}index.html` : `${id}/index.html`;
+	return extensions.some((extension) => publicAssets.has(id + extension) || publicAssets.has(index + extension));
+}
+function isPublicFileRequest(request, publicAssets) {
+	if (!STATIC_METHODS.has(request.method)) return false;
+	const extensions = [""];
+	for (const encoding of request.headers.get("accept-encoding")?.split(",") ?? []) {
+		const [name, ...params] = encoding.split(";");
+		const quality = params.map((param) => param.trim().split("=")).find(([key]) => key.toLowerCase() === "q")?.[1];
+		if ((quality === void 0 ? 1 : Number.parseFloat(quality)) <= 0) continue;
+		const extension = ENCODING_EXTENSIONS.get(name.trim().toLowerCase());
+		if (extension) extensions.push(extension);
+	}
+	return getRequestPathnames(request.url).some((pathname) => [pathname, toH3Pathname(pathname)].some((candidate) => candidate !== void 0 && isPublicFilePathname(candidate, extensions, publicAssets)));
+}
+function createNitroPublicFilesPlugin(options) {
+	const publicAssets = new Set(options.publicAssets);
+	return (nitroApp) => {
+		const appFetch = nitroApp.fetch;
+		const token = crypto.randomUUID();
+		Reflect.set(globalThis, Symbol.for(NITRO_ASSETS_KEY), {
+			async fetch(request) {
+				const headers = new Headers(request.headers);
+				headers.set(ASSET_REQUEST_HEADER, token);
+				return appFetch(new Request(request, { headers }));
+			},
+			isAssetRequest: (request) => request.headers.get(ASSET_REQUEST_HEADER) === token
+		});
+		if (publicAssets.size > 0) nitroApp.fetch = (request) => {
+			if (!isPublicFileRequest(request, publicAssets)) return appFetch(request);
+			return Promise.resolve().then(() => options.fetchApp(request)).catch((error) => {
+				console.error("[vinext]", error);
+				nitroApp.captureError?.(error, { tags: ["vinext"] });
+				return new Response(null, { status: 500 });
+			});
+		};
+	};
+}
+//#endregion
+export { NITRO_ASSETS_KEY, createNitroPublicFilesPlugin };

package/dist/server/nitro-public-files.d.ts

@@ -0,0 +1,22 @@
+import { VinextAssetFetcher } from "./multi-stage.js";
+//#region src/server/nitro-public-files.d.ts
+type NitroFetchEntry = {
+  fetch(request: Request): Promise<Response>;
+};
+/**
+ * Wrap the App Router SSR service that Nitro dispatches requests to, so a
+ * public file the router resolves is served by Nitro's static handler.
+ */
+export declare function withNitroPublicFiles(entry: NitroFetchEntry): NitroFetchEntry;
+type PagesWorkerEntry<Env, Context extends object> = {
+  fetch(request: Request, env: Env, ctx: Context & {
+    assets?: VinextAssetFetcher;
+  }): unknown;
+};
+/**
+ * Give the Pages Router worker that Nitro dispatches requests to an asset
+ * fetcher that reads files through Nitro's static handler.
+ */
+export declare function withNitroPagesPublicFiles<Env, Context extends object>(worker: PagesWorkerEntry<Env, Context>): PagesWorkerEntry<Env, Context>;
+//#endregion
+export {};

package/dist/server/nitro-public-files.js

@@ -0,0 +1,39 @@
+import { createStaticAssetRequest, resolveStaticAssetSignal } from "./worker-utils.js";
+import { NITRO_ASSETS_KEY } from "./nitro-public-files-plugin.js";
+//#region src/server/nitro-public-files.ts
+function getNitroAssets() {
+	const assets = Reflect.get(globalThis, Symbol.for(NITRO_ASSETS_KEY));
+	if (!assets) throw new Error("[vinext] The Nitro public files plugin did not run.");
+	return assets;
+}
+function notFound() {
+	return new Response(null, { status: 404 });
+}
+/**
+* Wrap the App Router SSR service that Nitro dispatches requests to, so a
+* public file the router resolves is served by Nitro's static handler.
+*/
+function withNitroPublicFiles(entry) {
+	return { async fetch(request) {
+		const assets = getNitroAssets();
+		if (assets.isAssetRequest(request)) return notFound();
+		const response = await entry.fetch(request);
+		return await resolveStaticAssetSignal(response, { fetchAsset: (path, requestHeaders) => assets.fetch(createStaticAssetRequest(path, request, requestHeaders)) }) ?? response;
+	} };
+}
+/**
+* Give the Pages Router worker that Nitro dispatches requests to an asset
+* fetcher that reads files through Nitro's static handler.
+*/
+function withNitroPagesPublicFiles(worker) {
+	return { fetch(request, env, ctx) {
+		const assets = getNitroAssets();
+		if (assets.isAssetRequest(request)) return notFound();
+		return worker.fetch(request, env, {
+			...ctx,
+			assets
+		});
+	} };
+}
+//#endregion
+export { withNitroPagesPublicFiles, withNitroPublicFiles };

package/dist/server/opentelemetry-api.d.ts

@@ -56,4 +56,5 @@ export type OpenTelemetryApi = {
 export declare function getOpenTelemetryRootContext(): OpenTelemetryContext;
 /** Resolve the API registered by the application, if any. */
 export declare function getOpenTelemetryApi(): OpenTelemetryApi | undefined;
-//#endregion
+//#endregion
+export {};

package/dist/server/operation-token.d.ts

@@ -36,4 +36,5 @@ export type OperationTokenVerificationPolicy = {
 export declare function verifyOperationToken(token: OperationToken, authority: OperationTokenAuthority, policy: OperationTokenVerificationPolicy): OperationTokenVerdict;
 export declare function verifyOperationTokenForCommit(token: OperationToken, authority: Pick<OperationTokenAuthority, "activeNavigationId" | "visibleCommitVersion">): OperationTokenVerdict;
 export declare function verifyOperationTokenForCacheReuse(token: OperationToken, authority: Pick<OperationTokenAuthority, "graphVersion" | "installedCacheVariantFingerprint">): OperationTokenVerdict;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-api-route.d.ts

@@ -85,4 +85,5 @@ type HandlePagesApiRouteOptions = {
   trustedRevalidateOrigin?: string;
 };
 export declare function handlePagesApiRoute(options: HandlePagesApiRouteOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-asset-tags.d.ts

@@ -9,6 +9,11 @@
  * unit-testable and lives in a normal typed module rather than a codegen
  * template string.
  */
+/**
+ * Fallback for when no build-time `sharedChunks` list is registered. Prefers
+ * the chunk-name based list the build writes into the SSR manifest; the file
+ * name scan only matches `[name]-[hash]` names, not hash-only ones.
+ */
 export declare function getSharedChunkFiles(manifest: Record<string, string[]>): string[];
 /**
  * Resolve the effective SSR manifest: prefer the caller-supplied object and
@@ -76,4 +81,5 @@ type CollectAssetTagsOptions = {
  * Extracted from `entries/pages-server-entry.ts`.
  */
 export declare function collectAssetTags(options: CollectAssetTagsOptions): string;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-asset-tags.js

@@ -1,6 +1,6 @@
 import { appendDeploymentIdQuery } from "../utils/deployment-id.js";
 import { createNonceAttribute } from "./html.js";
-import { assetServingUrlFromBaseAnchored } from "../utils/manifest-paths.js";
+import { SSR_MANIFEST_SHARED_CHUNKS_KEY, assetServingUrlFromBaseAnchored } from "../utils/manifest-paths.js";
 import { getPagesClientAssets } from "./pages-client-assets.js";
 //#region src/server/pages-asset-tags.ts
 /**
@@ -55,7 +55,14 @@ function findModuleKey(manifest, moduleId) {
 	}
 	return matchedKey;
 }
+/**
+* Fallback for when no build-time `sharedChunks` list is registered. Prefers
+* the chunk-name based list the build writes into the SSR manifest; the file
+* name scan only matches `[name]-[hash]` names, not hash-only ones.
+*/
 function getSharedChunkFiles(manifest) {
+	const recorded = manifest[SSR_MANIFEST_SHARED_CHUNKS_KEY];
+	if (recorded) return recorded;
 	const cached = sharedChunkFiles.get(manifest);
 	if (cached) return cached;
 	const files = /* @__PURE__ */ new Set();
@@ -186,7 +193,7 @@ function collectAssetTags(options) {
 				const files = getManifestFilesForModule(m, id);
 				if (files) for (let fi = 0; fi < files.length; fi++) allFiles.push(files[fi]);
 			}
-			const sharedFiles = m === runtimeAssets.ssrManifest && runtimeAssets.sharedChunks ? runtimeAssets.sharedChunks : getSharedChunkFiles(m);
+			const sharedFiles = runtimeAssets.sharedChunks ?? getSharedChunkFiles(m);
 			for (const file of sharedFiles) allFiles.push(file);
 		} else for (const akey in m) {
 			const avals = m[akey];

package/dist/server/pages-body-parser-config.d.ts

@@ -55,4 +55,5 @@ export declare function resolveBodyParserConfig(moduleConfig: {
     };
   };
 } | undefined, defaultSizeLimit?: number): ResolvedBodyParserConfig;
-//#endregion
+//#endregion
+export {};

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

@@ -1,10 +1,17 @@
+import { ClientReferenceChunks } from "../utils/client-reference-chunks.js";
 //#region src/server/pages-client-assets.d.ts
 export type AssetCrossOrigin = "" | "anonymous" | "use-credentials";
 export type PagesClientAssets = {
   clientEntry?: string;
   appBootstrapPreinitModules?: string[];
+  appRouteManifestModule?: string;
+  /** What each App Router client reference loads in the browser, by URL. */
+  appClientReferenceChunks?: ClientReferenceChunks;
   ssrManifest?: Record<string, string[]>;
-  /** Build-time shared file list, valid only for this ssrManifest object. */
+  /**
+   * Shared Pages chunk files (framework, vinext runtime, client entry) keyed on
+   * chunk names from this client build, in the SSR-manifest key-space.
+   */
   sharedChunks?: string[];
   cssGraph?: Record<string, {
     imports?: string[];

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

@@ -138,4 +138,5 @@ type NormalizePagesDataRequestResult = {
  * `runMiddleware` share a single implementation.
  */
 export declare function normalizePagesDataRequest(request: Request, buildId: string | null, basePath?: string, trailingSlash?: boolean): NormalizePagesDataRequestResult;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-document-asset-props.d.ts

@@ -26,4 +26,5 @@ export declare function extractDocumentAssetProps(html: string, token: string):
 export declare function markDocumentAssetPropsProtectedTags(html: string, markerAttribute: string): string;
 export declare function stripDocumentAssetPropsProtectionMarkers(html: string, markerAttribute: string): string;
 export declare function applyDocumentAssetProps(html: string, props: DocumentAssetProps, options?: ApplyDocumentAssetPropsOptions): string;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-document-initial-props.d.ts

@@ -78,4 +78,5 @@ type RunDocumentRenderPageResult = {
  * @see .nextjs-ref/packages/next/src/server/render.tsx (search `renderPage`)
  */
 export declare function runDocumentRenderPage(input: DocumentRenderPageInput): Promise<RunDocumentRenderPageResult>;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-execution-tracing.d.ts

@@ -37,4 +37,5 @@ export declare function createFindPageComponentsSpanDescriptor(routePattern: str
   readonly type: "NextNodeServer.findPageComponents";
 };
 export declare function traceFindPageComponents<T>(routePattern: string, callback: () => T): T;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-execution-tracing.js

@@ -1,6 +1,6 @@
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { frameworkTracer } from "./tracer.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 //#region src/server/pages-execution-tracing.ts
 function createPagesDataSpanDescriptor(method, routePattern) {
 	const route = patternToNextFormat(routePattern);

package/dist/server/pages-get-initial-props.d.ts

@@ -76,4 +76,5 @@ export type DevAppInitialPropsContext = {
  * data code does not run on the cache hot path.
  */
 export declare function loadDevAppInitialProps(ctx: DevAppInitialPropsContext): Promise<DevAppInitialPropsResult>;
-//#endregion
+//#endregion
+export {};

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

@@ -63,12 +63,30 @@ export declare function detectPathnameLocale(pathname: string, locales: readonly
  * `:locale`. After normalisation the request looks like `/en/to-sv` and
  * the rule matches with `:locale=en`.
  *
+ * `restoreRootTrailingSlash` makes the root `/en/` rather than `/en`; header
+ * callers compute it with `shouldRestoreLocaleRootTrailingSlash`. Redirect
+ * and rewrite callers do not pass it yet.
+ *
  * Ported from Next.js: packages/next/src/server/lib/router-utils/resolve-routes.ts
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/resolve-routes.ts
  */
 export declare function normalizeDefaultLocalePathname(pathname: string, i18n: NextI18nConfig | null | undefined, options?: {
   hostname?: string | null;
+  restoreRootTrailingSlash?: boolean;
 }): string;
+/**
+ * Whether Next.js re-adds the root's trailing slash after splicing in the
+ * default locale: the raw request pathname (basePath included, so `/docs`
+ * stays `/docs/en` while `/docs/` becomes `/docs/en/`) ends with `/`, and
+ * `trailingSlash` is on without `skipProxyUrlNormalize`.
+ *
+ * Ported from Next.js: packages/next/src/server/lib/router-utils/resolve-routes.ts
+ * (`hadTrailingSlash` + `maybeAddTrailingSlash`).
+ */
+export declare function shouldRestoreLocaleRootTrailingSlash(rawPathname: string, config: {
+  trailingSlash?: boolean;
+  skipProxyUrlNormalize?: boolean;
+}): boolean;
 /**
  * Extract locale prefix from a URL path.
  * e.g. /fr/about -> { locale: "fr", url: "/about", hadPrefix: true }

package/dist/server/pages-i18n.js

@@ -51,6 +51,10 @@ function detectPathnameLocale(pathname, locales) {
 * `:locale`. After normalisation the request looks like `/en/to-sv` and
 * the rule matches with `:locale=en`.
 *
+* `restoreRootTrailingSlash` makes the root `/en/` rather than `/en`; header
+* callers compute it with `shouldRestoreLocaleRootTrailingSlash`. Redirect
+* and rewrite callers do not pass it yet.
+*
 * Ported from Next.js: packages/next/src/server/lib/router-utils/resolve-routes.ts
 * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/resolve-routes.ts
 */
@@ -59,10 +63,22 @@ function normalizeDefaultLocalePathname(pathname, i18n, options = {}) {
 	if (pathname.startsWith("/_next/") || pathname.startsWith("/__vinext/")) return pathname;
 	if (detectPathnameLocale(pathname, i18n.locales)) return pathname;
 	const defaultLocale = detectDomainLocale(i18n.domains, options.hostname ?? void 0)?.defaultLocale ?? i18n.defaultLocale;
-	if (pathname === "/") return `/${defaultLocale}`;
+	if (pathname === "/") return options.restoreRootTrailingSlash ? `/${defaultLocale}/` : `/${defaultLocale}`;
 	return `/${defaultLocale}${pathname}`;
 }
 /**
+* Whether Next.js re-adds the root's trailing slash after splicing in the
+* default locale: the raw request pathname (basePath included, so `/docs`
+* stays `/docs/en` while `/docs/` becomes `/docs/en/`) ends with `/`, and
+* `trailingSlash` is on without `skipProxyUrlNormalize`.
+*
+* Ported from Next.js: packages/next/src/server/lib/router-utils/resolve-routes.ts
+* (`hadTrailingSlash` + `maybeAddTrailingSlash`).
+*/
+function shouldRestoreLocaleRootTrailingSlash(rawPathname, config) {
+	return Boolean(config.trailingSlash && !config.skipProxyUrlNormalize && rawPathname.endsWith("/"));
+}
+/**
 * Extract locale prefix from a URL path.
 * e.g. /fr/about -> { locale: "fr", url: "/about", hadPrefix: true }
 *      /about    -> { locale: defaultLocale, url: "/about", hadPrefix: false }
@@ -243,4 +259,4 @@ function resolvePagesI18nRequest(url, i18nConfig, headers, hostname, basePath =
 	};
 }
 //#endregion
-export { detectDomainLocale, detectLocaleFromAcceptLanguage, detectPathnameLocale, extractLocaleFromUrl, getLocaleRedirect, normalizeDefaultLocalePathname, parseCookieLocaleFromHeader, resolvePagesI18nRequest, stripI18nLocaleForApiRoute };
+export { detectDomainLocale, detectLocaleFromAcceptLanguage, detectPathnameLocale, extractLocaleFromUrl, getLocaleRedirect, normalizeDefaultLocalePathname, parseCookieLocaleFromHeader, resolvePagesI18nRequest, shouldRestoreLocaleRootTrailingSlash, stripI18nLocaleForApiRoute };