vinext 1.3.0 → 1.3.1

package/dist/routing/app-route-graph.js

@@ -131,7 +131,7 @@ function createStaticSegmentGraph(routes) {
 				treePath
 			});
 		}
-		addRouteManifestSegmentErrorBoundaryFacts({
+		addRouteManifestSegmentBoundaryFacts({
 			boundaries,
 			route
 		});
@@ -303,19 +303,42 @@ function addRouteManifestBoundaryFacts(input) {
 	addRouteManifestBoundaryFact(input, "forbidden", input.route.forbiddenPaths[input.layoutIndex]);
 	addRouteManifestBoundaryFact(input, "unauthorized", input.route.unauthorizedPaths[input.layoutIndex]);
 }
-function addRouteManifestSegmentErrorBoundaryFacts(input) {
-	for (const [index, boundaryPath] of (input.route.errorPaths ?? []).entries()) {
-		const treePosition = input.route.errorTreePositions?.[index];
-		assertRouteManifestBoundaryTreePosition(input.route, boundaryPath, treePosition);
-		const ownerLayoutId = findRouteManifestOwnerLayoutId(input.route, treePosition);
+function addRouteManifestSegmentBoundaryFacts(input) {
+	const { route } = input;
+	const segmentBoundaries = [
+		[
+			"error",
+			route.errorPaths,
+			route.errorTreePositions
+		],
+		[
+			"notFound",
+			route.segmentNotFoundPaths,
+			route.segmentNotFoundTreePositions
+		],
+		[
+			"forbidden",
+			route.segmentForbiddenPaths,
+			route.segmentForbiddenTreePositions
+		],
+		[
+			"unauthorized",
+			route.segmentUnauthorizedPaths,
+			route.segmentUnauthorizedTreePositions
+		]
+	];
+	for (const [outcome, boundaryPaths, treePositions] of segmentBoundaries) for (const [index, boundaryPath] of (boundaryPaths ?? []).entries()) {
+		const treePosition = treePositions?.[index];
+		assertRouteManifestBoundaryTreePosition(route, boundaryPath, treePosition);
+		const ownerLayoutId = findRouteManifestOwnerLayoutId(route, treePosition);
 		if (ownerLayoutId !== null) continue;
-		const treePath = createAppRouteGraphTreePath(input.route.routeSegments, treePosition);
+		const treePath = createAppRouteGraphTreePath(route.routeSegments, treePosition);
 		addRouteManifestBoundaryFact({
 			boundaries: input.boundaries,
-			route: input.route,
+			route,
 			layoutId: ownerLayoutId,
 			treePath
-		}, "error", boundaryPath);
+		}, outcome, boundaryPath);
 	}
 }
 function addRouteManifestBoundaryFact(input, outcome, boundaryPath) {
@@ -458,14 +481,11 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const subPage = slotPages.get(slot.key);
 			if (subPage !== void 0) {
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
-				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage, matcher);
 				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
-					notFoundPath: notFoundBoundary.path,
-					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: rawSegments
 				}, subPage, matcher);
 			}
@@ -547,14 +567,11 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const subSlots = parentRoute.parallelSlots.map((slot) => {
 				const subPage = slotPages.get(slot.key);
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
-				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage ?? null, matcher);
 				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage || null,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
-					notFoundPath: notFoundBoundary.path,
-					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: subPage ? rawSegments : null
 				}, subPage ?? null, matcher);
 			});
@@ -593,6 +610,12 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				unauthorizedPath: parentRoute.unauthorizedPath,
 				unauthorizedTreePosition: parentRoute.unauthorizedTreePosition,
 				unauthorizedPaths: parentRoute.unauthorizedPaths,
+				segmentNotFoundPaths: parentRoute.segmentNotFoundPaths,
+				segmentNotFoundTreePositions: parentRoute.segmentNotFoundTreePositions,
+				segmentForbiddenPaths: parentRoute.segmentForbiddenPaths,
+				segmentForbiddenTreePositions: parentRoute.segmentForbiddenTreePositions,
+				segmentUnauthorizedPaths: parentRoute.segmentUnauthorizedPaths,
+				segmentUnauthorizedTreePositions: parentRoute.segmentUnauthorizedTreePositions,
 				routeSegments: [...parentRoute.routeSegments, ...rawSegments],
 				childrenRouteSegments: childrenDefault ? parentRoute.routeSegments : void 0,
 				templateTreePositions: parentRoute.templateTreePositions,
@@ -680,52 +703,52 @@ function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
 	});
 }
 function findSlotLoadingEntries(slotDir, pagePath, matcher) {
+	return findSlotSegmentFileEntries(slotDir, pagePath, "loading", matcher);
+}
+/** Find a convention file in each directory from the slot root to the page, outermost first. */
+function findSlotSegmentFileEntries(slotDir, pagePath, fileName, matcher) {
 	const pageDir = pagePath ? path.dirname(pagePath) : slotDir;
 	if (pageDir !== slotDir && !pageDir.startsWith(`${slotDir}${path.sep}`)) return [];
 	const relativeDir = path.relative(slotDir, pageDir);
 	const segments = relativeDir ? relativeDir.split(path.sep).filter(Boolean) : [];
-	const loadings = [];
+	const entries = [];
 	let currentDir = slotDir;
-	const rootLoading = findFile(currentDir, "loading", matcher);
-	if (rootLoading) loadings.push({
-		path: rootLoading,
+	const rootEntry = findFile(currentDir, fileName, matcher);
+	if (rootEntry) entries.push({
+		path: rootEntry,
 		treePosition: 0
 	});
 	for (let index = 0; index < segments.length; index++) {
 		currentDir = path.join(currentDir, segments[index]);
-		const loading = findFile(currentDir, "loading", matcher);
-		if (loading) loadings.push({
-			path: loading,
+		const entry = findFile(currentDir, fileName, matcher);
+		if (entry) entries.push({
+			path: entry,
 			treePosition: index + 1
 		});
 	}
-	return loadings;
+	return entries;
 }
 function withSlotLoadingEntries(slot, pagePath, matcher) {
 	const loadingEntries = findSlotLoadingEntries(slot.ownerDir, pagePath, matcher);
 	return {
 		...slot,
 		loadingPaths: loadingEntries.map((entry) => entry.path),
-		loadingTreePositions: loadingEntries.map((entry) => entry.treePosition)
+		loadingTreePositions: loadingEntries.map((entry) => entry.treePosition),
+		...findSlotNotFoundFields(slot.ownerDir, pagePath, matcher)
 	};
 }
-function findSlotNotFoundBoundary(slotDir, pagePath, matcher) {
-	let dir = pagePath ? path.dirname(pagePath) : slotDir;
-	while (dir === slotDir || dir.startsWith(`${slotDir}${path.sep}`)) {
-		const boundaryPath = findFile(dir, "not-found", matcher);
-		if (boundaryPath) {
-			const relativeDir = path.relative(slotDir, dir);
-			return {
-				path: boundaryPath,
-				treePosition: relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0
-			};
-		}
-		if (dir === slotDir) break;
-		dir = path.dirname(dir);
-	}
+/**
+* Every not-found convention on the slot's active branch, plus the nearest one,
+* which supplies the slot's not-found metadata.
+*/
+function findSlotNotFoundFields(slotDir, pagePath, matcher) {
+	const entries = findSlotSegmentFileEntries(slotDir, pagePath, "not-found", matcher);
+	const nearest = entries.at(-1);
 	return {
-		path: null,
-		treePosition: null
+		notFoundPath: nearest?.path ?? null,
+		notFoundTreePosition: nearest?.treePosition ?? null,
+		notFoundPaths: entries.map((entry) => entry.path),
+		notFoundTreePositions: entries.map((entry) => entry.treePosition)
 	};
 }
 /**
@@ -801,6 +824,10 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 	const notFoundPaths = discoverBoundaryFilePerLayout(layouts, "not-found", matcher);
 	const forbiddenPaths = discoverBoundaryFilePerLayout(layouts, "forbidden", matcher);
 	const unauthorizedPaths = discoverBoundaryFilePerLayout(layouts, "unauthorized", matcher);
+	const discoverPageSegmentBoundaryFiles = (fileName) => pagePath === null && routePath !== null ? [] : discoverSegmentBoundaryFiles(segments, appDir, fileName, matcher);
+	const segmentNotFounds = discoverPageSegmentBoundaryFiles("not-found");
+	const segmentForbiddens = discoverPageSegmentBoundaryFiles("forbidden");
+	const segmentUnauthorizeds = discoverPageSegmentBoundaryFiles("unauthorized");
 	const parallelSlots = discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, includeNestedOnlySlots);
 	return {
 		ids: createAppRouteSemanticIds({
@@ -833,6 +860,12 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 		forbiddenTreePosition: forbiddenEntry?.treePosition ?? null,
 		unauthorizedPath,
 		unauthorizedTreePosition: unauthorizedEntry?.treePosition ?? null,
+		segmentNotFoundPaths: segmentNotFounds.map((entry) => entry.path),
+		segmentNotFoundTreePositions: segmentNotFounds.map((entry) => entry.treePosition),
+		segmentForbiddenPaths: segmentForbiddens.map((entry) => entry.path),
+		segmentForbiddenTreePositions: segmentForbiddens.map((entry) => entry.treePosition),
+		segmentUnauthorizedPaths: segmentUnauthorizeds.map((entry) => entry.path),
+		segmentUnauthorizedTreePositions: segmentUnauthorizeds.map((entry) => entry.treePosition),
 		unauthorizedPaths,
 		routeSegments: segments,
 		templateTreePositions,
@@ -1034,6 +1067,24 @@ function discoverBoundaryFileEntry(segments, appDir, fileName, matcher) {
 	return null;
 }
 /**
+* Discover boundary files (not-found, forbidden, unauthorized) by segment tree
+* position. As with error.tsx, Next.js wraps each segment's children in its
+* boundary whether or not the segment has a layout.
+*/
+function discoverSegmentBoundaryFiles(segments, appDir, fileName, matcher) {
+	const boundaries = [];
+	let currentDir = appDir;
+	for (let index = 0; index <= segments.length; index++) {
+		if (index > 0) currentDir = path.join(currentDir, segments[index - 1]);
+		const boundary = findFile(currentDir, fileName, matcher);
+		if (boundary) boundaries.push({
+			path: boundary,
+			treePosition: index
+		});
+	}
+	return boundaries;
+}
+/**
 * Discover boundary files (not-found, forbidden, unauthorized) at each layout directory.
 * Returns an array aligned with the layouts array, where each entry is the boundary
 * file at that layout's directory, or null if none exists there.
@@ -1271,7 +1322,6 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
 		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
 		const loadingEntries = findSlotLoadingEntries(slotDir, pagePath, matcher);
-		const notFoundBoundary = findSlotNotFoundBoundary(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
 			key: `${slotName}@${path.relative(appDir, slotDir)}`,
@@ -1289,8 +1339,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			loadingPaths: loadingEntries.map((loading) => loading.path),
 			loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
 			errorPath: findFile(slotDir, "error", matcher),
-			notFoundPath: notFoundBoundary.path,
-			notFoundTreePosition: notFoundBoundary.treePosition,
+			...findSlotNotFoundFields(slotDir, pagePath, matcher),
 			interceptingRoutes,
 			layoutIndex: -1,
 			routeSegments: pagePath ? [] : null
@@ -1440,7 +1489,7 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
 */
-function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher, parentLoadingEntries = []) {
+function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher, parentLoadingEntries = [], parentLayoutPaths = []) {
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	for (const entry of entries) {
@@ -1450,13 +1499,14 @@ function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, res
 		const interceptDir = path.join(currentDir, entry.name);
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
-			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher, [], parentLoadingEntries, path.relative(slotRootDir, currentDir).split(path.sep).filter(Boolean).length);
+			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher, parentLayoutPaths, parentLoadingEntries, path.relative(slotRootDir, currentDir).split(path.sep).filter(Boolean).length);
 		} else {
+			const layout = findFile(interceptDir, "layout", matcher);
 			const loading = findFile(interceptDir, "loading", matcher);
 			scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher, loading ? [...parentLoadingEntries, {
 				path: loading,
 				treePosition: path.relative(slotRootDir, interceptDir).split(path.sep).filter(Boolean).length
-			}] : parentLoadingEntries);
+			}] : parentLoadingEntries, layout ? [...parentLayoutPaths, layout] : parentLayoutPaths);
 		}
 	}
 }
@@ -1486,7 +1536,15 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
-			const notFoundBoundary = findSlotNotFoundBoundary(slotRootDir ?? interceptRoot, page, matcher);
+			const notFoundTreePositionOffset = slotRootDir ? 0 : 1;
+			const notFoundFields = findSlotNotFoundFields(slotRootDir ?? interceptRoot, page, matcher);
+			const findInterceptBoundaries = (fileName) => findSlotSegmentFileEntries(slotRootDir ?? interceptRoot, page, fileName, matcher).map((entry) => ({
+				path: entry.path,
+				treePosition: entry.treePosition + notFoundTreePositionOffset
+			}));
+			const forbiddenBoundaries = findInterceptBoundaries("forbidden");
+			const unauthorizedBoundaries = findInterceptBoundaries("unauthorized");
+			const errorBoundaries = findInterceptBoundaries("error");
 			const slotParentSegments = slotRootDir ? path.relative(slotRootDir, interceptParentDir).split(path.sep).filter(Boolean) : [];
 			const branchSegments = [
 				...slotParentSegments,
@@ -1498,7 +1556,9 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 				convention,
 				layoutPaths: [...layoutPaths],
 				layoutSegments: layoutPaths.map((layoutPath) => {
-					const relativeDir = path.relative(interceptRoot, path.dirname(layoutPath));
+					const layoutDir = path.dirname(layoutPath);
+					if (slotRootDir && layoutDir !== interceptRoot && !layoutDir.startsWith(`${interceptRoot}${path.sep}`)) return path.relative(slotRootDir, layoutDir).split(path.sep).filter(Boolean);
+					const relativeDir = path.relative(interceptRoot, layoutDir);
 					return [
 						...slotParentSegments,
 						interceptSegment,
@@ -1508,8 +1568,20 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 				loadingPaths: loadingEntries.map((loading) => loading.path),
 				loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
 				notFoundBranchSegments: branchSegments,
-				notFoundPath: notFoundBoundary.path,
-				notFoundTreePosition: notFoundBoundary.treePosition === null ? null : slotRootDir ? notFoundBoundary.treePosition : notFoundBoundary.treePosition + 1,
+				notFoundPath: notFoundFields.notFoundPath,
+				notFoundTreePosition: notFoundFields.notFoundTreePosition == null ? null : notFoundFields.notFoundTreePosition + notFoundTreePositionOffset,
+				notFoundPaths: notFoundFields.notFoundPaths,
+				notFoundTreePositions: notFoundFields.notFoundTreePositions?.map((treePosition) => treePosition + notFoundTreePositionOffset),
+				forbiddenPath: forbiddenBoundaries.at(-1)?.path ?? null,
+				forbiddenTreePosition: forbiddenBoundaries.at(-1)?.treePosition ?? null,
+				forbiddenPaths: forbiddenBoundaries.map((boundary) => boundary.path),
+				forbiddenTreePositions: forbiddenBoundaries.map((boundary) => boundary.treePosition),
+				unauthorizedPath: unauthorizedBoundaries.at(-1)?.path ?? null,
+				unauthorizedTreePosition: unauthorizedBoundaries.at(-1)?.treePosition ?? null,
+				unauthorizedPaths: unauthorizedBoundaries.map((boundary) => boundary.path),
+				unauthorizedTreePositions: unauthorizedBoundaries.map((boundary) => boundary.treePosition),
+				errorPaths: errorBoundaries.map((boundary) => boundary.path),
+				errorTreePositions: errorBoundaries.map((boundary) => boundary.treePosition),
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,

package/dist/routing/browser-route-manifest.d.ts

@@ -40,4 +40,5 @@ export type BrowserRouteManifestWire = {
 };
 export declare function toBrowserRouteManifestWire(routeManifest: RouteManifest): BrowserRouteManifestWire;
 export declare function decodeBrowserRouteManifest(wire: BrowserRouteManifestWire): BrowserRouteManifest;
-//#endregion
+//#endregion
+export {};

package/dist/routing/optimistic-route-trie.d.ts

@@ -24,4 +24,5 @@ export type OptimisticRouteTrieMatch<Route extends OptimisticTrieRoute> = {
 };
 export declare function buildOptimisticRouteTrie<Route extends OptimisticTrieRoute>(routes: Iterable<Route>, onDynamicSegmentConflict?: (existingParamName: string, part: string) => void): OptimisticRouteTrieNode<Route>;
 export declare function matchOptimisticRouteTrie<Route extends OptimisticTrieRoute>(trie: OptimisticRouteTrieNode<Route>, urlParts: readonly string[]): OptimisticRouteTrieMatch<Route> | null;
-//#endregion
+//#endregion
+export {};

package/dist/routing/route-matching.d.ts

@@ -35,4 +35,5 @@ export declare function matchRouteWithTrieRawPathname<R extends {
   route: R;
   params: Record<string, string | string[]>;
 } | null;
-//#endregion
+//#endregion
+export {};

package/dist/routing/route-pattern.d.ts

@@ -68,4 +68,5 @@ export declare function normalizeStaticPathname(pathname: string): string;
  * locale handling should be added here, not duplicated at call sites.
  */
 export declare function normalizeStaticPathsEntry(entry: StaticPathsEntry, routePattern: string): NormalizedStaticPathsEntry;
-//#endregion
+//#endregion
+export {};

package/dist/server/accept-encoding.d.ts

@@ -23,4 +23,5 @@ export declare function selectContentEncoding<T extends ContentEncoding>(parsed:
 export declare const HAS_ZSTD: boolean;
 /** Select by client q-value first, then zstd > br > gzip > deflate > identity. */
 export declare function negotiateEncoding(req: IncomingMessage): NegotiatedEncoding;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-action-forwarding.d.ts

@@ -22,4 +22,5 @@ export declare function createForwardedActionContext(executionContext: Execution
   actionForwarded: true;
 } & Partial<ExecutionContextLike>;
 export declare function forwardServerActionIfNeeded(options: ForwardServerActionOptions): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-bfcache-identity.d.ts

@@ -31,4 +31,5 @@ export declare function preserveBfcacheIdsForMergedElements(options: {
   preservedElementIds?: readonly string[];
   preservePreviousIds?: readonly string[];
 }): BfcacheIdMap;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-action-result.d.ts

@@ -62,4 +62,5 @@ type DiscardedServerActionRefreshSchedulerOptions = {
   runRefresh: () => void;
 };
 export declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-client-reuse-manifest.d.ts

@@ -7,4 +7,5 @@ type CreateClientReuseManifestHeaderOptions = Readonly<{
   limits?: ClientReuseManifestLimits;
 }>;
 export declare function createClientReuseManifestHeaderFromVisibleAppState(state: VisibleAppState, options?: CreateClientReuseManifestHeaderOptions): string | null;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-entry.js

@@ -15,7 +15,7 @@ import { DevRecoveryBoundary, GlobalErrorBoundary, RedirectBoundary } from "../s
 import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
 import { BfcacheIdentityMapContext, bindAppElementsRenderedSearch, setAppElementsRenderedSearch } from "../shims/slot.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath, isRscCompatibilityIdCompatible } from "./app-rsc-cache-busting.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import "../client/instrumentation-client.js";
 import { createNavigationRuntimeRouteManifestLoader, getNavigationRuntime, loadNavigationRuntimeRouteManifest, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
@@ -43,7 +43,7 @@ import { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition,
 import { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, createProdOnRecoverableError } from "./app-browser-error.js";
 import { createHydrationCachePublication } from "./app-hydration-cache-publication.js";
 import { peekSettledPrefetchResponseForNavigation, prepareConsumedPrefetchResponseForPublication, preserveCommittedPrefetchExpiry, resolvePrefetchNavigationResponseUrl } from "./app-browser-prefetch-response.js";
-import { canCommitOptimisticRouteTemplate, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, resolveOptimisticNavigationParamsForHref, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
+import { canCommitOptimisticRouteTemplate, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, keepOptimisticStreamingMetadata, resolveOptimisticNavigationParamsForHref, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
 import { removeStylesheetLinksCoveredByInlineCss } from "./app-inline-css-client.js";
 import { createElement, startTransition, use, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { flushSync } from "react-dom";
@@ -67,6 +67,15 @@ const MAX_VISITED_RESPONSE_CACHE_SIZE = 50;
 const IS_STATIC_EXPORT = process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export";
 let clientDeploymentVersion = null;
 let clientRscCompatibilityId = IS_STATIC_EXPORT ? null : "vinext:missing";
+/**
+* Decoding a payload loads the chunks its client references name, so a
+* payload this page can't navigate to is only decoded by the navigation that
+* hard-navigates. Otherwise a prefetch after a deploy would load the new
+* deployment's code and stylesheets into this page.
+*/
+function isRscResponseCompatible(compatibilityIdHeader) {
+	return isRscCompatibilityIdCompatible(compatibilityIdHeader, clientRscCompatibilityId);
+}
 function setClientRscCompatibilityId(compatibilityId) {
 	if (IS_STATIC_EXPORT || !compatibilityId) return;
 	clientRscCompatibilityId = compatibilityId;
@@ -309,6 +318,10 @@ async function fetchPersistedSourcePageRefresh(options) {
 * read the query the server rendered it with, not the navigation's.
 */
 async function decodeSupplementalRefresh(response, targetPathname) {
+	if (!isRscResponseCompatible(response.headers.get("X-Vinext-RSC-Compatibility-Id"))) {
+		response.body?.cancel().catch(() => {});
+		throw new Error("[vinext] Refreshed another deployment's payload");
+	}
 	const elements = await decodeAppElementsPromise(createFromFetch(Promise.resolve(response)));
 	const renderedPathAndSearch = parseRenderedPathAndSearchHeader(response.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER));
 	setAppElementsRenderedSearch(elements, new URL(renderedPathAndSearch ?? targetPathname, window.location.origin).search);
@@ -333,6 +346,7 @@ async function learnOptimisticRouteTemplateFromPrefetch(options) {
 	if (source.interceptionContext !== options.interceptionContext) return false;
 	if (resolvePrefetchCacheEntryMountedSlotsHeader(options.entry) !== options.mountedSlotsHeader) return false;
 	if (options.interceptionContext !== null) return false;
+	if (!isRscResponseCompatible(options.entry.snapshot.compatibilityIdHeader)) return false;
 	const elements = await decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(options.entry.snapshot))));
 	const template = createOptimisticRouteTemplate({
 		allowLoadingShell: options.entry.optimisticRouteShell === true,
@@ -1118,6 +1132,12 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 			let currentPrevNextUrl = previousNextUrlOverride;
 			let redirectCount = redirectDepth;
 			let detachedNavigationCommits = false;
+			let optimisticShellElements = null;
+			const keepOptimisticShellMetadata = (payload) => {
+				const shellElements = optimisticShellElements;
+				if (shellElements === null) return payload;
+				return payload instanceof Promise ? payload.then((elements) => keepOptimisticStreamingMetadata(elements, shellElements, String(navId))) : keepOptimisticStreamingMetadata(payload, shellElements, String(navId));
+			};
 			const activeTraversalIntent = navigationKind === "traverse" ? traversalIntent ?? historyController.resolveTraversalIntent(window.history.state) : null;
 			let startedHardNavigation = false;
 			const performHardNavigationForScrollIntent = (targetHref, mode) => {
@@ -1284,7 +1304,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							navId,
 							operationLane: toOperationLane(navigationKind),
 							params: cachedParams,
-							payload: cachedPayload,
+							payload: keepOptimisticShellMetadata(cachedPayload),
 							payloadOrigin: cachedRoute.elements ? COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN : VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN,
 							pendingRouterState: detachedNavigationCommits ? null : pendingRouterState,
 							previousNextUrl: requestPreviousNextUrl,
@@ -1372,6 +1392,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 								template: optimisticPayload.template
 							})) {
 								detachedNavigationCommits = true;
+								optimisticShellElements = optimisticPayload.elements;
 								const optimisticNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, optimisticPayload.params);
 								renderNavigationPayload({
 									actionType: toActionType(navigationKind),
@@ -1518,7 +1539,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						},
 						operationLane: toOperationLane(navigationKind),
 						params: navParams,
-						payload: rscPayload,
+						payload: keepOptimisticShellMetadata(rscPayload),
 						payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
 						pendingRouterState: detachedNavigationCommits ? null : pendingRouterState,
 						previousNextUrl: requestPreviousNextUrl,
@@ -1527,7 +1548,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						scrollIntent,
 						targetHref: currentHref,
 						traversalIntent: activeTraversalIntent,
-						visibleCommitMode: prefetchedElements ? "synchronous" : visibleCommitMode
+						visibleCommitMode
 					});
 					if (renderOutcome === "hard-navigate") {
 						startedHardNavigation = true;
@@ -1585,7 +1606,10 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 				if (startedHardNavigation) await waitForMpaNavigationRestore();
 			}
 		},
-		preparePrefetchResponse: (response) => decodeAppElementsPromise(createFromFetch(Promise.resolve(response))),
+		preparePrefetchResponse: (response) => {
+			if (!isRscResponseCompatible(response.headers.get("X-Vinext-RSC-Compatibility-Id"))) return Promise.reject(/* @__PURE__ */ new Error("[vinext] Prefetched another deployment's payload"));
+			return decodeAppElementsPromise(createFromFetch(Promise.resolve(response)));
+		},
 		claimCurrentHistoryTreeSnapshot: (historyUpdateMode, previousHistoryState) => historyController.claimCurrentHistoryTreeSnapshot(historyUpdateMode, previousHistoryState),
 		commitAppOwnedHistoryStateWrite: (historyUpdateMode, previousHistoryState) => historyController.commitAppOwnedHistoryStateWrite(historyUpdateMode, previousHistoryState),
 		discardPendingNavigation: () => {

package/dist/server/app-browser-error.d.ts

@@ -10,4 +10,5 @@ export declare function createOnUncaughtError(options?: {
 export declare function createProdOnCaughtError(onImplicitRootError: HydrateRootErrorHandler): HydrateRootErrorHandler;
 export declare function createDevOnCaughtError(onCaughtError: HydrateRootErrorHandler, onImplicitRootError: HydrateRootErrorHandler): HydrateRootErrorHandler;
 export declare function createProdOnRecoverableError(onReportedError: () => void): (error: unknown) => void;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-history-controller.d.ts

@@ -121,4 +121,5 @@ export declare class AppBrowserHistoryController {
    */
   restoreHistorySnapshot(options: RestoreHistorySnapshotOptions): boolean;
 }
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-hydration.d.ts

@@ -38,4 +38,5 @@ export declare function resolveFetchedHydrationLocation(renderedPathAndSearch: s
   pathname: string;
   search: string;
 };
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-interception-context.d.ts

@@ -20,4 +20,5 @@ type ResolveManifestNavigationInterceptionContextOptions = {
  */
 export declare function resolveManifestNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
 export declare function resolveMiddlewareRewriteNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-navigation-controller.js

@@ -333,8 +333,12 @@ function createAppBrowserNavigationController(deps = {}) {
 			routeManifest: deps.getRouteManifest?.() ?? null,
 			targetHref: createSnapshotPathAndSearch(navigationSnapshot)
 		});
-		if (approval.approvedCommit) dispatchSynchronousVisibleCommit(approval.approvedCommit);
-		else if (approval.decision.disposition === "hard-navigate") performHardNavigation(createSnapshotPathAndSearch(navigationSnapshot));
+		if (approval.approvedCommit) {
+			const approvedHmrCommit = approval.approvedCommit;
+			startTransition(() => {
+				dispatchVisibleCommit(approvedHmrCommit);
+			});
+		} else if (approval.decision.disposition === "hard-navigate") performHardNavigation(createSnapshotPathAndSearch(navigationSnapshot));
 	}
 	/**
 	* Rendered before the route tree (see createAppRouteTree). Insertion effects
@@ -357,7 +361,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		}, [renderId]);
 		return children;
 	}
-	function dispatchApprovedVisibleCommit(renderId, commit, pendingRouterState, visibleCommitMode) {
+	function dispatchApprovedVisibleCommit(renderId, commit, pendingRouterState, visibleCommitMode, republishPendingRouterState) {
 		const setter = getBrowserRouterStateSetter();
 		const pendingCommit = pendingNavigationCommits.get(renderId);
 		const captureCandidateState = (state) => {
@@ -370,7 +374,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			pendingRouterState.settled = true;
 			pendingRouterState.resolve(committedState);
 			if (activePendingBrowserRouterState === pendingRouterState) activePendingBrowserRouterState = null;
-			if (visibleCommitMode === "synchronous") flushSync(() => {
+			if (republishPendingRouterState) startTransition(() => {
 				setter(committedState);
 			});
 			return;
@@ -387,7 +391,8 @@ function createAppBrowserNavigationController(deps = {}) {
 			setter(committedState);
 		});
 	}
-	function dispatchSynchronousVisibleCommit(commit) {
+	/** Calls the setter directly; the caller chooses the update's priority. */
+	function dispatchVisibleCommit(commit) {
 		getBrowserRouterStateSetter()(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
 	}
 	function createRestoredHistorySnapshotCommit(options) {
@@ -444,7 +449,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		});
 		if (approval.approvedCommit === null) return false;
 		options.beforeCommit?.();
-		dispatchSynchronousVisibleCommit(approval.approvedCommit);
+		dispatchVisibleCommit(approval.approvedCommit);
 		return true;
 	}
 	function notifyDiscardedServerActionRevalidation(lifecycleOptions) {
@@ -462,7 +467,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			return false;
 		}
 	}
-	function shouldForceSynchronousCommit(options) {
+	function shouldRepublishPendingRouterState(options) {
 		if (options.actionType === "traverse") return false;
 		if (options.historyUpdateMode === void 0) return false;
 		if (options.scrollIntent?.hash == null) return false;
@@ -566,12 +571,12 @@ function createAppBrowserNavigationController(deps = {}) {
 				activateNavigationSnapshot();
 				snapshotRenderIds.add(renderId);
 			}
-			dispatchApprovedVisibleCommit(renderId, approvedCommit, options.pendingRouterState, shouldForceSynchronousCommit(options) ? "synchronous" : options.visibleCommitMode ?? "transition");
+			dispatchApprovedVisibleCommit(renderId, approvedCommit, options.pendingRouterState, options.visibleCommitMode ?? "transition", shouldRepublishPendingRouterState(options));
 			if (options.navigationResponseCompletion) options.navigationResponseCompletion.then(() => {
 				if (!isCurrentNavigation(options.navId) || !hasBrowserRouterState()) return;
 				const committedState = pendingNavigationCommits.get(renderId)?.committedState;
 				if (!committedState) return;
-				flushSync(() => {
+				startTransition(() => {
 					getBrowserRouterStateSetter()(committedState);
 				});
 			}, () => {});
@@ -634,7 +639,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			if (latestApproval.approvedCommit) {
 				const approvedRevalidationCommit = latestApproval.approvedCommit;
 				startTransition(() => {
-					dispatchSynchronousVisibleCommit(approvedRevalidationCommit);
+					dispatchVisibleCommit(approvedRevalidationCommit);
 				});
 				syncHistoryStatePreviousNextUrl(approvedRevalidationCommit.previousNextUrl, approvedRevalidationCommit.action.bfcacheIds);
 			} else notifyDiscardedServerActionRevalidation(lifecycleOptions);

package/dist/server/app-browser-popstate.d.ts

@@ -26,4 +26,5 @@ export declare function shouldCommitPopstateUrlWithoutNavigation(options: {
   isSameAppRouteTarget: boolean;
 }): boolean;
 export declare function createPopstateRestoreHandler(deps: BrowserPopstateRestoreDeps): (event: PopStateEvent) => void;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-rsc-redirect.d.ts

@@ -34,4 +34,5 @@ export declare function resolveStreamedRscRedirectLifecycleHop(options: {
   requestPreviousNextUrl: string | null;
   streamedRedirectTarget: string;
 }): RscRedirectLifecycleDecision;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-server-action-client.d.ts

@@ -30,4 +30,5 @@ export type ClientServerActionDeps = {
   syncServerActionHttpFallbackHead(status: number | null): void;
 };
 export declare function invokeClientServerAction(id: string, args: unknown[], actionInitiation: ClientServerActionInitiation, deps: ClientServerActionDeps): Promise<unknown>;
-//#endregion
+//#endregion
+export {};