vinext 1.4.2 → 1.4.3

package/dist/init.js

@@ -1,8 +1,9 @@
 import path, { toSlash } from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { detectPackageManager, detectPackageManagerName, detectProject, ensureESModule, findViteConfigPath, hasViteConfig, renameCJSConfigs } from "./utils/project.js";
 import { compactResourceName, cssModulesConfigSource, findConfigKeepingWorkerName, setupCloudflarePlatform, updateViteConfigForCssModules, usesCommonJsViteConfig, validateCloudflarePlatformSetup } from "./init-cloudflare.js";
-import { getReactUpgradeDeps } from "./utils/react-version.js";
+import { findPackageVersion, getReactUpgradeDeps } from "./utils/react-version.js";
 import { getPluginReactUpgradeDeps } from "./utils/plugin-react-version.js";
+import { createRequire } from "node:module";
 import fs from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 //#region src/init.ts
@@ -297,6 +298,26 @@ function addDependencyEntries(root, deps, { dev }) {
 	if (added.length > 0) fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
 	return added;
 }
+/** The spec in the manifest sections `isDepInstalled` reads. */
+function readDeclaredDependency(root, name) {
+	try {
+		const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
+		return pkg.dependencies?.[name] ?? pkg.devDependencies?.[name] ?? pkg.peerDependencies?.[name];
+	} catch {
+		return;
+	}
+}
+/** The declared spec, or the installed version of a package hoisted from elsewhere. */
+function readCurrentDependencyVersion(root, name) {
+	const declared = readDeclaredDependency(root, name);
+	if (declared !== void 0) return declared;
+	try {
+		const resolved = createRequire(path.join(root, "package.json")).resolve(name);
+		return findPackageVersion(resolved, name) ?? void 0;
+	} catch {
+		return;
+	}
+}
 /**
 * Check if react/react-dom need upgrading for react-server-dom-webpack compatibility.
 *
@@ -578,12 +599,20 @@ async function init(options) {
 	let dependencyInstallNeedsApproval = false;
 	const dependencyEntriesAdded = [];
 	const devDependencyEntriesAdded = [];
+	const upgradedFrom = /* @__PURE__ */ new Map();
+	const recordUpgrades = (deps) => {
+		for (const dep of deps) {
+			const { name } = parseDependencySpecifier(dep);
+			upgradedFrom.set(name, readCurrentDependencyVersion(root, name));
+		}
+	};
 	if (isApp) {
 		const reactUpgrade = shouldInstall ? [.../* @__PURE__ */ new Set([...getReactUpgradeDeps(root), ...getReactUpgradeDeps(root, {
 			fromManifest: true,
 			installing: true
 		})])] : getReactUpgradeDeps(root, { fromManifest: true });
 		if (reactUpgrade.length > 0) {
+			recordUpgrades(reactUpgrade);
 			console.log(`  ${terminalStyle.cyan(terminalStyle.bold("Upgrading dependencies:"))}`);
 			console.log(formatList(reactUpgrade.map((dep) => dep.replace(/@latest$/, "")), "    "));
 			try {
@@ -601,6 +630,7 @@ async function init(options) {
 	}
 	const pluginReactUpgrade = getPluginReactUpgradeDeps(root);
 	if (pluginReactUpgrade.length > 0) {
+		recordUpgrades(pluginReactUpgrade);
 		console.log(`  ${terminalStyle.cyan(terminalStyle.bold("Upgrading devDependencies:"))}`);
 		console.log(formatList(pluginReactUpgrade.map((dep) => dep.replace(/@latest$/, "")), "    "));
 		try {
@@ -654,13 +684,20 @@ async function init(options) {
 	if (pmName === "pnpm" && shouldInstall && !dependencyInstallNeedsApproval && !options._exec && hasAutomaticallyIgnoredBuilds(inspectPnpmIgnoredBuilds(root))) dependencyInstallNeedsApproval = true;
 	else if (pmName === "pnpm" && shouldInstall && !dependencyInstallNeedsApproval && options._inspectPnpmIgnoredBuilds && hasAutomaticallyIgnoredBuilds(options._inspectPnpmIgnoredBuilds(root))) dependencyInstallNeedsApproval = true;
 	console.log(`  ${terminalStyle.green(terminalStyle.bold("vinext init complete!"))}\n`);
-	if (dependencyEntriesAdded.length > 0) {
+	const addedDependencies = dependencyEntriesAdded.filter((name) => !upgradedFrom.has(name));
+	const addedDevDependencies = devDependencyEntriesAdded.filter((name) => !upgradedFrom.has(name));
+	if (addedDependencies.length > 0) {
 		console.log(`    ${terminalStyle.green("✓")} Added dependencies to dependencies:`);
-		console.log(formatList(dependencyEntriesAdded, "      "));
+		console.log(formatList(addedDependencies, "      "));
 	}
-	if (devDependencyEntriesAdded.length > 0) {
+	if (addedDevDependencies.length > 0) {
 		console.log(`    ${terminalStyle.green("✓")} Added dependencies to devDependencies:`);
-		console.log(formatList(devDependencyEntriesAdded, "      "));
+		console.log(formatList(addedDevDependencies, "      "));
+	}
+	for (const [name, from] of upgradedFrom) {
+		const to = readDeclaredDependency(root, name);
+		if (to === void 0 || to === from) continue;
+		console.log(`    ${terminalStyle.green("✓")} Upgraded ${name} ${from ?? "(not installed)"} \u2192 ${to}`);
 	}
 	if (dependencyInstallNeedsApproval) console.log(`    ${terminalStyle.yellow("!")} Dependency installation is waiting for build-script approval`);
 	if (addedTypeModule) console.log(`    ${terminalStyle.green("✓")} Added "type": "module" to package.json`);

package/dist/server/api-handler.js

@@ -186,10 +186,14 @@ function enhanceApiObjects(req, res, query, body, trustedRevalidateOrigin, allow
 			return this;
 		},
 		json(data) {
-			this.setHeader("Content-Type", "application/json");
+			this.setHeader("Content-Type", "application/json; charset=utf-8");
 			this.end(JSON.stringify(data));
 		},
 		send(data) {
+			if (data === null || data === void 0) {
+				this.end();
+				return;
+			}
 			if (this.statusCode === 204 || this.statusCode === 304) {
 				this.removeHeader("Content-Type");
 				this.removeHeader("Content-Length");
@@ -208,8 +212,8 @@ function enhanceApiObjects(req, res, query, body, trustedRevalidateOrigin, allow
 				this.end(data);
 				return;
 			}
-			if (typeof data === "object" && data !== null) {
-				this.setHeader("Content-Type", "application/json");
+			if (typeof data === "object" || typeof data === "number" || typeof data === "boolean") {
+				this.setHeader("Content-Type", "application/json; charset=utf-8");
 				this.end(JSON.stringify(data));
 			} else {
 				if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "text/plain");

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

@@ -1,8 +1,5 @@
-import { addBasePathToPathname, stripBasePath } from "../utils/base-path.js";
 import { VINEXT_MOUNTED_LAYOUTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
-import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
-import { matchRoutePattern } from "../routing/route-pattern.js";
 import { installWindowNext, setWindowNextInternalSourcePage } from "../client/window-next.js";
 import { retryScrollTo, scrollToHashTargetOnNextFrame } from "../shims/hash-scroll.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath, isRscCompatibilityIdCompatible } from "./app-rsc-cache-busting.js";
@@ -32,7 +29,7 @@ import { COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, FRESH_APP_NAVIGATION_PAY
 import { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, navigateDocumentDirectly } from "./app-browser-navigation-controller.js";
 import { createAppRouteTree } from "./app-route-tree.js";
 import { shouldRecoverSamePathSearchCommitOnResponseCompletion } from "./app-browser-navigation-response.js";
-import { createSupplementalRefreshCoordinator, mergeRefreshedParallelSlot, requireCompleteSupplementalRefresh, resolvePersistedSourcePageRefreshes, resolveServerActionSupplementalRefresh, resolveSupplementalRefreshes } from "./app-browser-supplemental-refresh.js";
+import { createSupplementalRefreshCoordinator, mergeRefreshedParallelSlot, requireCompleteSupplementalRefresh, resolvePersistedRefreshInterceptions, resolvePersistedSourcePageRefreshes, resolveServerActionSupplementalRefresh, resolveSupplementalRefreshes } from "./app-browser-supplemental-refresh.js";
 import { createAppBrowserNavigationAbortCoordinator } from "./app-browser-navigation-abort.js";
 import { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition, resolveFetchedHydrationLocation } from "./app-browser-hydration.js";
 import { AppBrowserHistoryController } from "./app-browser-history-controller.js";
@@ -278,36 +275,6 @@ function clearDynamicClientNavigationCaches() {
 	optimisticRouteTemplates.clear();
 	historyController.invalidateRestorableClientState();
 }
-function getMatchedUrlPathname(matchedUrl) {
-	return new URL(matchedUrl, "https://vinext.local").pathname;
-}
-function resolvePersistedRefreshInterceptions(state, routeManifest, refreshUrl, requestInterceptionContext) {
-	if (routeManifest === null) return [];
-	const refreshPathname = stripBasePath(refreshUrl.pathname, __basePath);
-	const refreshPathParts = splitPathnameForRouteMatch(refreshPathname);
-	const resolved = [];
-	for (const binding of state.slotBindings) {
-		if (binding.state !== "active" || !binding.activeRouteId) continue;
-		if (!binding.interceptionId || !binding.interceptionSourceMatchedUrl) continue;
-		const activeRoute = AppElementsWire.parseElementKey(binding.activeRouteId);
-		if (activeRoute?.kind !== "route") continue;
-		const match = routeManifest.segmentGraph.interceptions.get(binding.interceptionId);
-		if (!match) continue;
-		const retainedInterception = state.interception?.slotId === binding.slotId && matchRoutePattern(splitPathnameForRouteMatch(getMatchedUrlPathname(state.interception.targetMatchedUrl)), match.targetPatternParts) !== null ? state.interception : null;
-		const targetPathname = retainedInterception?.targetMatchedUrl ?? activeRoute.path;
-		const targetParts = splitPathnameForRouteMatch(getMatchedUrlPathname(targetPathname));
-		if (requestInterceptionContext !== null && state.interception?.slotId === binding.slotId && matchRoutePattern(refreshPathParts, match.targetPatternParts) !== null && matchRoutePattern(targetParts, match.targetPatternParts) !== null) continue;
-		const targetUrl = new URL(targetPathname, refreshUrl);
-		targetUrl.pathname = addBasePathToPathname(targetUrl.pathname, __basePath);
-		targetUrl.search = refreshUrl.search;
-		resolved.push({
-			interception: match,
-			interceptionContext: retainedInterception?.sourceMatchedUrl ?? binding.interceptionSourceMatchedUrl,
-			targetPathname: `${targetUrl.pathname}${targetUrl.search}`
-		});
-	}
-	return resolved;
-}
 async function fetchPersistedInterceptedSlotRefresh(options) {
 	const headers = createRscRequestHeaders({
 		interceptionContext: options.interceptionContext,
@@ -482,7 +449,13 @@ async function commitSameUrlNavigatePayload(nextElements, actionInitiation, retu
 	if (revalidation !== "none" && routeManifestLoaded) {
 		const refreshUrl = new URL(actionInitiation.href);
 		const requestInterceptionContext = resolveInterceptionContextFromPreviousNextUrl(actionInitiation.routerState.previousNextUrl, __basePath);
-		const persistedInterceptions = resolvePersistedRefreshInterceptions(actionInitiation.routerState, getBrowserRouteManifest(), refreshUrl, requestInterceptionContext);
+		const persistedInterceptions = resolvePersistedRefreshInterceptions({
+			basePath: __basePath,
+			refreshUrl,
+			requestInterceptionContext,
+			routeManifest: getBrowserRouteManifest(),
+			state: actionInitiation.routerState
+		});
 		const sourcePageRefreshes = resolvePersistedSourcePageRefreshes({
 			basePath: __basePath,
 			refreshUrl,
@@ -1094,7 +1067,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 	const formState = consumeInitialFormState(getVinextBrowserGlobal());
 	const hydrateRootOptions = import.meta.env.DEV && devErrorOverlay ? createVinextHydrateRootOptions({
 		formState,
-		onCaughtError: invalidateOnCaughtError(createDevOnCaughtError(devErrorOverlay.devOnCaughtError, onUncaughtError)),
+		onCaughtError: invalidateOnCaughtError(createDevOnCaughtError(devErrorOverlay.devOnCaughtError, onUncaughtError, devErrorOverlay.reportRootErrorBoundaryCatch)),
 		onUncaughtError
 	}) : createVinextHydrateRootOptions({
 		formState,
@@ -1195,7 +1168,13 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					const requestInterceptionContext = requestState.interceptionContext;
 					const requestPreviousNextUrl = requestState.previousNextUrl;
 					const shouldSupplementVisibleBranches = navigationKind === "refresh" || navigationKind === "traverse" && !reuseCurrentBfcacheIds;
-					const persistedRefreshInterceptions = navigationKind === "refresh" ? resolvePersistedRefreshInterceptions(navigationInitiationState, getBrowserRouteManifest(), url, requestInterceptionContext) : [];
+					const persistedRefreshInterceptions = navigationKind === "refresh" ? resolvePersistedRefreshInterceptions({
+						basePath: __basePath,
+						refreshUrl: url,
+						requestInterceptionContext,
+						routeManifest: getBrowserRouteManifest(),
+						state: navigationInitiationState
+					}) : [];
 					const persistedSourcePageRefreshes = shouldSupplementVisibleBranches ? resolvePersistedSourcePageRefreshes({
 						activeRoutePaths: navigationKind === "traverse" ? readHistoryStateActiveRoutePaths(activeTraversalIntent?.historyState) ?? [] : void 0,
 						basePath: __basePath,

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

@@ -8,7 +8,7 @@ export declare function createOnUncaughtError(options?: {
   coerceToError?: boolean;
 }): HydrateRootErrorHandler;
 export declare function createProdOnCaughtError(onImplicitRootError: HydrateRootErrorHandler): HydrateRootErrorHandler;
-export declare function createDevOnCaughtError(onCaughtError: HydrateRootErrorHandler, onImplicitRootError: HydrateRootErrorHandler): HydrateRootErrorHandler;
+export declare function createDevOnCaughtError(onCaughtError: HydrateRootErrorHandler, onImplicitRootError: HydrateRootErrorHandler, onRootErrorBoundaryCatch?: () => void): HydrateRootErrorHandler;
 export declare function createProdOnRecoverableError(onReportedError: () => void): (error: unknown) => void;
 //#endregion
 export {};

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

@@ -2,10 +2,18 @@ import { isUnknownRecord } from "../utils/record.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { isBailoutToCSRError } from "../shims/navigation-errors.js";
 //#region src/server/app-browser-error.ts
-function isImplicitRootErrorBoundary(errorInfo) {
-	if (!isUnknownRecord(errorInfo.errorBoundary)) return false;
+function getErrorBoundaryProps(errorInfo) {
+	if (!isUnknownRecord(errorInfo.errorBoundary)) return {};
 	const props = errorInfo.errorBoundary.props;
-	return isUnknownRecord(props) && props.isImplicitRootErrorBoundary === true;
+	return isUnknownRecord(props) ? props : {};
+}
+function isImplicitRootErrorBoundary(errorInfo) {
+	return getErrorBoundaryProps(errorInfo).isImplicitRootErrorBoundary === true;
+}
+function isRootErrorBoundary(errorInfo) {
+	const props = getErrorBoundaryProps(errorInfo);
+	if (props.isGlobalErrorBoundary === true) return true;
+	return props.isImplicitRootErrorBoundary === true && props.wrapsGlobalErrorBoundary !== true;
 }
 function logCaughtError(error, errorInfo) {
 	console.error(error);
@@ -38,8 +46,9 @@ function createProdOnCaughtError(onImplicitRootError) {
 		logCaughtError(error, errorInfo);
 	};
 }
-function createDevOnCaughtError(onCaughtError, onImplicitRootError) {
+function createDevOnCaughtError(onCaughtError, onImplicitRootError, onRootErrorBoundaryCatch) {
 	return (error, errorInfo) => {
+		if (!isNavigationSignalError(error) && isRootErrorBoundary(errorInfo)) onRootErrorBoundaryCatch?.();
 		if (isImplicitRootErrorBoundary(errorInfo)) {
 			onImplicitRootError(error, errorInfo);
 			return;

package/dist/server/app-browser-supplemental-refresh.d.ts

@@ -1,3 +1,4 @@
+import { BrowserRouteManifest, BrowserRouteManifestInterception } from "../routing/browser-route-manifest.js";
 import { AppElements } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { AppRouterState } from "./app-browser-state.js";
@@ -31,6 +32,18 @@ export declare function resolvePersistedSourcePageRefreshes(options: {
   refreshUrl: URL;
   state: Pick<AppRouterState, "previousNextUrl" | "slotBindings">;
 }): string[];
+export type PersistedRefreshInterception = {
+  interception: BrowserRouteManifestInterception;
+  interceptionContext: string;
+  targetPathname: string;
+};
+export declare function resolvePersistedRefreshInterceptions(options: {
+  basePath: string;
+  refreshUrl: URL;
+  requestInterceptionContext: string | null;
+  routeManifest: BrowserRouteManifest | null;
+  state: Pick<AppRouterState, "interception" | "slotBindings">;
+}): PersistedRefreshInterception[];
 export declare function createSupplementalRefreshCoordinator(): {
   abortAll(): void;
   begin(options: {

package/dist/server/app-browser-supplemental-refresh.js

@@ -1,6 +1,7 @@
-import { addBasePathToPathname, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
-import { normalizePathnameForRouteMatch } from "../routing/utils.js";
+import { removeTrailingSlash, restoreBasePath, stripBasePath } from "../utils/base-path.js";
+import { normalizePathnameForRouteMatch, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { normalizePath } from "./normalize-path.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
 import { APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_SLOT_BINDINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { isNestedBfcacheSlotSegmentIdFor } from "./bfcache-identity.js";
@@ -131,7 +132,7 @@ function resolvePersistedSourcePageRefreshes(options) {
 	});
 	for (const activeRoutePath of activeRoutePaths) {
 		if (activeRoutePath !== refreshRoutePathname && (refreshRoutePathname === "/" || activeRoutePath.startsWith(refreshRoutePathname + "/"))) continue;
-		const pathname = addBasePathToPathname(activeRoutePath, options.basePath);
+		const pathname = restoreBasePath(activeRoutePath, options.basePath);
 		if (sourceUrlsByPathname.has(pathname)) continue;
 		const sourceUrl = new URL(pathname, options.refreshUrl);
 		sourceUrl.search = options.refreshUrl.search;
@@ -145,6 +146,37 @@ function resolvePersistedSourcePageRefreshes(options) {
 	}
 	return resolved;
 }
+function getMatchedUrlPathname(matchedUrl) {
+	return new URL(matchedUrl, "https://vinext.local").pathname;
+}
+function resolvePersistedRefreshInterceptions(options) {
+	const { basePath, refreshUrl, requestInterceptionContext, routeManifest, state } = options;
+	if (routeManifest === null) return [];
+	const refreshPathname = stripBasePath(refreshUrl.pathname, basePath);
+	const refreshPathParts = splitPathnameForRouteMatch(refreshPathname);
+	const resolved = [];
+	for (const binding of state.slotBindings) {
+		if (binding.state !== "active" || !binding.activeRouteId) continue;
+		if (!binding.interceptionId || !binding.interceptionSourceMatchedUrl) continue;
+		const activeRoute = AppElementsWire.parseElementKey(binding.activeRouteId);
+		if (activeRoute?.kind !== "route") continue;
+		const match = routeManifest.segmentGraph.interceptions.get(binding.interceptionId);
+		if (!match) continue;
+		const retainedInterception = state.interception?.slotId === binding.slotId && matchRoutePattern(splitPathnameForRouteMatch(getMatchedUrlPathname(state.interception.targetMatchedUrl)), match.targetPatternParts) !== null ? state.interception : null;
+		const targetPathname = retainedInterception?.targetMatchedUrl ?? activeRoute.path;
+		const targetParts = splitPathnameForRouteMatch(getMatchedUrlPathname(targetPathname));
+		if (requestInterceptionContext !== null && state.interception?.slotId === binding.slotId && matchRoutePattern(refreshPathParts, match.targetPatternParts) !== null && matchRoutePattern(targetParts, match.targetPatternParts) !== null) continue;
+		const targetUrl = new URL(targetPathname, refreshUrl);
+		targetUrl.pathname = restoreBasePath(targetUrl.pathname, basePath);
+		targetUrl.search = refreshUrl.search;
+		resolved.push({
+			interception: match,
+			interceptionContext: retainedInterception?.sourceMatchedUrl ?? binding.interceptionSourceMatchedUrl,
+			targetPathname: `${targetUrl.pathname}${targetUrl.search}`
+		});
+	}
+	return resolved;
+}
 function createSupplementalRefreshCoordinator() {
 	const controllers = /* @__PURE__ */ new Set();
 	return {
@@ -202,4 +234,4 @@ async function resolveSupplementalRefreshes(options) {
 	}
 }
 //#endregion
-export { SupplementalRefreshError, createSupplementalRefreshCoordinator, mergeRefreshedParallelSlot, requireCompleteSupplementalRefresh, resolvePersistedSourcePageRefreshes, resolveServerActionSupplementalRefresh, resolveSupplementalRefreshes };
+export { SupplementalRefreshError, createSupplementalRefreshCoordinator, mergeRefreshedParallelSlot, requireCompleteSupplementalRefresh, resolvePersistedRefreshInterceptions, resolvePersistedSourcePageRefreshes, resolveServerActionSupplementalRefresh, resolveSupplementalRefreshes };

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

@@ -26,6 +26,8 @@ export type ApplyAppMiddlewareOptions = {
   middlewareRequest?: Request;
   module: MiddlewareModule;
   request: Request;
+  /** Forwarded to `executeMiddleware`. */
+  restoreLocaleRootTrailingSlash?: boolean;
   validateExternalRewriteRequest?: () => Promise<Response | null>;
   /**
    * Forwarded to `executeMiddleware` so the NextRequest exposes a NextURL with

package/dist/server/app-middleware.js

@@ -203,6 +203,7 @@ async function applyAppMiddleware(options) {
 				},
 				requestBodyAlreadyIsolated: true,
 				request: middlewareRequest,
+				restoreLocaleRootTrailingSlash: options.restoreLocaleRootTrailingSlash,
 				skipTrailingSlashRedirect: options.skipTrailingSlashRedirect,
 				trailingSlash: options.trailingSlash
 			});

package/dist/server/app-page-boundary-render.js

@@ -85,8 +85,10 @@ function wrapRenderedBoundaryElement(options) {
 		renderErrorBoundary(GlobalErrorComponent, children) {
 			return createElement(GlobalErrorBoundary, {
 				fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+				wrapsGlobalErrorBoundary: true,
 				children: createElement(ErrorBoundary, {
 					fallback: GlobalErrorComponent,
+					isGlobalErrorBoundary: true,
 					children
 				})
 			});

package/dist/server/app-page-dispatch.d.ts

@@ -166,6 +166,7 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, options?: {
     isForceStatic?: boolean;
     isUncacheableRender?: boolean;
+    routeTreeOnlyPrefetchShell?: boolean;
     /** Layouts the navigating client holds, which the render may leave out. */
     mountedLayouts?: ReadonlySet<string> | null;
     observeMetadataSearchParamsAccess?: boolean;

package/dist/server/app-page-dispatch.js

@@ -293,7 +293,8 @@ async function dispatchAppPageInner(options) {
 	const isOnDemandRevalidate = _isOnDemandRevalidate();
 	const shouldReadCache = isStoredRender && !isOnDemandRevalidate;
 	const isCacheCandidate = isCacheEligibleRender && isStaticEligible && options.pprFallbackShell === void 0 && !isNeverStoredPath;
-	const isUncacheableRender = !(isCacheEligibleRender && isStaticEligible) && options.pprFallbackShell === void 0 && (options.pprRuntime === void 0 || !options.isProduction);
+	const routeTreeOnlyPrefetchShell = options.pprFallbackShell === void 0 && (options.pprRuntime === void 0 || !options.isProduction);
+	const isUncacheableRender = !(isCacheEligibleRender && isStaticEligible) && routeTreeOnlyPrefetchShell;
 	const mountedLayouts = isUncacheableRender && options.isRscRequest && (options.renderMode ?? "navigation") === "navigation" && options.interceptionContext === null && options.isProgressiveActionRender !== true ? parseMountedLayoutsHeader(options.request.headers.get(VINEXT_MOUNTED_LAYOUTS_HEADER)) : null;
 	if (shouldReadCache && isStaticEligible) {
 		traceOperation = resolveAppPageTraceOperation({
@@ -387,6 +388,7 @@ async function dispatchAppPageInner(options) {
 						isForceStatic: revalidationDynamicConfig === "force-static",
 						observeMetadataSearchParamsAccess: revalidationDynamicConfig !== "force-static",
 						observePageSearchParamsAccess: revalidationDynamicConfig !== "force-static",
+						routeTreeOnlyPrefetchShell,
 						serveStreamingMetadata: placeGeneratedMetadataInBody,
 						placeStreamedMetadataInHead: true,
 						onHeadPrepared(head) {
@@ -552,6 +554,7 @@ async function dispatchAppPageInner(options) {
 				observeMetadataSearchParamsAccess: interceptDynamicConfig !== "force-static",
 				observePageSearchParamsAccess: interceptDynamicConfig !== "force-static",
 				isUncacheableRender,
+				routeTreeOnlyPrefetchShell,
 				serveStreamingMetadata: placeGeneratedMetadataInBody,
 				placeStreamedMetadataInHead: options.renderWholeDocument === true,
 				onHeadPrepared
@@ -611,6 +614,7 @@ async function dispatchAppPageInner(options) {
 				observeMetadataSearchParamsAccess: !isForceStatic,
 				observePageSearchParamsAccess: !isForceStatic,
 				isUncacheableRender,
+				routeTreeOnlyPrefetchShell,
 				mountedLayouts: interceptResult.interceptOpts ? null : mountedLayouts,
 				serveStreamingMetadata: placeGeneratedMetadataInBody,
 				placeStreamedMetadataInHead: options.renderWholeDocument === true,

package/dist/server/app-page-element-builder.d.ts

@@ -66,6 +66,8 @@ export type AppPagePageRequest<TModule extends AppPageModule = AppPageModule> =
   isForceStatic?: boolean;
   /** The render can never be stored (see buildAppPageElements). */
   isUncacheableRender?: boolean;
+  /** A loading shell without a loading boundary is the route tree (see buildAppPageElements). */
+  routeTreeOnlyPrefetchShell?: boolean;
   /** Layouts the navigating client holds (see buildAppPageElements). */
   mountedLayouts?: ReadonlySet<string> | null;
   /** Observe page metadata `searchParams` access for cache-safety classification. */

package/dist/server/app-page-element-builder.js

@@ -107,7 +107,7 @@ function traceAppPageInterceptLayoutModules(modules, branchSegments, layoutSegme
 async function buildPageElements(options) {
 	const { route, params, routePath, displayPathname = routePath, pageRequest, globalErrorModule, rootNotFoundModule, rootForbiddenModule, rootUnauthorizedModule, metadataRoutes } = options;
 	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
-	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, isUncacheableRender = false, mountedLayouts = null, serveStreamingMetadata, placeStreamedMetadataInHead = false, isProduction = process.env.NODE_ENV === "production", onHeadPrepared } = pageRequest;
+	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, isUncacheableRender = false, routeTreeOnlyPrefetchShell = false, mountedLayouts = null, serveStreamingMetadata, placeStreamedMetadataInHead = false, isProduction = process.env.NODE_ENV === "production", onHeadPrepared } = pageRequest;
 	const pageModule = route.page;
 	const isSiblingIntercept = opts?.interceptSlotKey === "__vinext_page_intercept" && !!opts?.interceptPage;
 	const effectivePageModule = isSiblingIntercept ? opts.interceptPage : pageModule;
@@ -414,6 +414,7 @@ async function buildPageElements(options) {
 			globalErrorModule: globalErrorModule ?? DEFAULT_GLOBAL_ERROR_MODULE,
 			isRscRequest,
 			isUncacheableRender,
+			routeTreeOnlyPrefetchShell,
 			interceptionId: opts?.interceptionId ?? null,
 			mountedLayouts,
 			mountedSlotIds,

package/dist/server/app-page-route-wiring.d.ts

@@ -220,11 +220,7 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
   isRscRequest?: boolean;
   /**
    * The render can never be stored and, in production, is never sent with
-   * static cache headers (see app-page-dispatch.ts), so a loading-shell
-   * prefetch without a loading boundary may skip its layouts. A render that
-   * may be stored keeps them, so a layout's dynamic API read still keeps it
-   * out of the cache. An explicit CDN cache policy on a dynamic route can
-   * still store the route tree, as a CDN would store Next.js's.
+   * static cache headers (see app-page-dispatch.ts).
    */
   isUncacheableRender?: boolean;
   /**
@@ -236,6 +232,12 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
   mountedLayouts?: ReadonlySet<string> | null;
   mountedSlotIds?: ReadonlySet<string> | null;
   renderIdentity?: AppPageRenderIdentity;
+  /**
+   * The render has no PPR (see app-page-dispatch.ts), so a loading-shell
+   * prefetch without a loading boundary sends only the route tree. Without it,
+   * the layouts render, as Next.js renders them with isRoutePPREnabled.
+   */
+  routeTreeOnlyPrefetchShell?: boolean;
   renderMode?: AppRscRenderMode;
   routePath: string;
   semanticPageIdentity?: Readonly<{

package/dist/server/app-page-route-wiring.js

@@ -514,7 +514,7 @@ function buildAppPageElements(options) {
 		[pageElementId]: null,
 		[routeId]: null
 	};
-	if (isPrefetchLoadingShell && !shouldRenderPrefetchLoadingShell && options.isUncacheableRender === true) return {
+	if (isPrefetchLoadingShell && !shouldRenderPrefetchLoadingShell && options.routeTreeOnlyPrefetchShell === true) return {
 		...metadataEntries,
 		...options.route.staticSiblings && options.route.staticSiblings.length > 0 ? { [APP_STATIC_SIBLINGS_KEY]: options.route.staticSiblings } : {},
 		[pageElementId]: null,
@@ -981,8 +981,10 @@ function buildAppPageElements(options) {
 	const globalErrorComponent = getErrorBoundaryExport(options.globalErrorModule);
 	routeChildren = /* @__PURE__ */ jsx(GlobalErrorBoundary, {
 		fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+		wrapsGlobalErrorBoundary: globalErrorComponent !== null,
 		children: globalErrorComponent ? /* @__PURE__ */ jsx(ErrorBoundary, {
 			fallback: globalErrorComponent,
+			isGlobalErrorBoundary: true,
 			children: routeChildren
 		}) : routeChildren
 	});

package/dist/server/app-pages-bridge.d.ts

@@ -57,6 +57,12 @@ type RenderPagesFallbackOptions = {
   pathname?: string;
   pagesDataRequest?: Request | null;
   request: Request;
+  /**
+   * The basePath `request.url` still carries. The page renderer receives the
+   * URL without it, as in the Pages Router pipeline, so `req.url` and `asPath`
+   * leave it out like Next.js.
+   */
+  requestBasePath?: string;
   /** The shared cache entry answers every host; a request-time render is not stored. */
   sharedAcrossHosts?: boolean;
   url: URL;

package/dist/server/app-pages-bridge.js

@@ -1,5 +1,7 @@
+import { stripBasePath } from "../utils/base-path.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
+import { isLocaleRedirect, markLocaleRedirect } from "./pages-i18n.js";
 import { beginRouteCacheability, markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
 import { mergeHeaders } from "./worker-utils.js";
 import { pagesRouteHasPriorityOverAppRoute } from "./hybrid-route-priority.js";
@@ -18,7 +20,7 @@ function applyPagesMiddlewareContext(response, middlewareContext) {
 * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
 */
 async function renderPagesFallback(options, dependencies) {
-	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, initialResponseHeaders, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, sharedAcrossHosts = false, url } = options;
+	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, initialResponseHeaders, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, requestBasePath = "", sharedAcrossHosts = false, url } = options;
 	const { loadPagesEntry, buildRequestHeaders, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
 	if (isRscRequest && !allowRscDocumentFallback) return null;
 	const pagesEntry = await loadPagesEntry();
@@ -67,8 +69,10 @@ async function renderPagesFallback(options, dependencies) {
 		if (runtimeDataKind === "server" || runtimeDataKind === "initial") markRouteCacheabilityDynamic("getInitialProps render shares a cache entry across hosts");
 	}
 	const pagesRequest = claimPagesRequest();
+	const renderRequestUrl = new URL(pagesDataRequest?.url ?? pagesRequest.url);
+	if (!pagesDataRequest) renderRequestUrl.pathname = stripBasePath(renderRequestUrl.pathname, requestBasePath);
 	const renderArgs = [
-		pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest,
+		renderRequestUrl.href === pagesRequest.url ? pagesRequest : cloneRequestWithUrl(pagesRequest, renderRequestUrl.href),
 		pagesUrl,
 		{},
 		getRequestExecutionContext() ?? void 0,
@@ -76,7 +80,8 @@ async function renderPagesFallback(options, dependencies) {
 	];
 	const pagesRes = isDataRequest ? await (initialResponseHeaders ? pagesEntry.renderPage(...renderArgs, { isDataReq: true }, initialResponseHeaders) : pagesEntry.renderPage(...renderArgs, { isDataReq: true })) : await (initialResponseHeaders ? pagesEntry.renderPage(...renderArgs, void 0, initialResponseHeaders) : pagesEntry.renderPage(...renderArgs));
 	if (pagesRes.status === 404 && pageMatch === null) return null;
-	return applyDraftModeCookie(applyPagesMiddlewareContext(pagesRes, middlewareContext), getDraftModeCookieHeader());
+	const response = applyDraftModeCookie(applyPagesMiddlewareContext(pagesRes, middlewareContext), getDraftModeCookieHeader());
+	return isLocaleRedirect(pagesRes) ? markLocaleRedirect(response) : response;
 }
 /**
 * Append a middleware-emitted `__prerender_bypass` Set-Cookie header to a Pages

package/dist/server/app-request-stage-independent-entry.js

@@ -9,7 +9,7 @@ import "./server-globals.js";
 import { getExplicitCdnCacheAdapter } from "../shims/cdn-cache-state.js";
 import { applyCdnResponseIdentityHeaders, validateCdnRequest } from "./cache-control.js";
 import { registerLazyDataCacheHandler } from "../shims/cache-handler.js";
-import { getImageOptimizer, readImageOptimizationSignal } from "./image-optimization.js";
+import { readImageOptimizationSignal } from "./image-optimization.js";
 import { consumeFrameworkRequestRoute, traceFrameworkRequest } from "./request-tracing.js";
 import { createStaticAssetRequest, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderStateFromHeaders } from "./prerender-route-params.js";
@@ -75,7 +75,6 @@ async function handleRequest(request, env, platformCtx, dispatchResponseStage, a
 		if (cdnValidationResponse) return cdnValidationResponse;
 	}
 	const url = new URL(request.url);
-	const servesImages = Boolean(assets) && getImageOptimizer() !== null;
 	const protocolRelativeGuard = guardProtocolRelativeUrl(url.pathname, url.search);
 	if (protocolRelativeGuard) return protocolRelativeGuard;
 	try {
@@ -104,7 +103,7 @@ async function handleRequest(request, env, platformCtx, dispatchResponseStage, a
 	};
 	const handle = () => requestRscHandler(request, ctx, trackedDispatchResponseStage, probeMode, ctx.isPrerenderPathDiscovery === true, trustedPrerenderState);
 	let response = await runWithExecutionContext(ctx, handle);
-	const imageSignal = servesImages ? readImageOptimizationSignal(response) : null;
+	const imageSignal = assets ? readImageOptimizationSignal(response) : null;
 	if (imageSignal && assets) {
 		const { fetchSignalledPublicFile, serveWorkerImageOptimization } = await import("./worker-image-optimization.js");
 		response = await serveWorkerImageOptimization(request, imageSignal, __imageAllowedWidths, __imageConfig, {

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

@@ -8,7 +8,7 @@ import { runWithExecutionContext } from "../shims/request-context.js";
 import "./server-globals.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { applyCdnResponseIdentityHeaders, validateCdnRequest } from "./cache-control.js";
-import { getImageOptimizer, readImageOptimizationSignal } from "./image-optimization.js";
+import { readImageOptimizationSignal } from "./image-optimization.js";
 import { traceFrameworkRequest } from "./request-tracing.js";
 import { createStaticAssetRequest, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
@@ -83,7 +83,6 @@ async function handleRequest(request, env, platformCtx) {
 	const cdnValidationResponse = await validateCdnRequest(request);
 	if (cdnValidationResponse) return cdnValidationResponse;
 	const url = new URL(request.url);
-	const servesImages = Boolean(assets) && getImageOptimizer() !== null;
 	const protocolRelativeGuard = guardProtocolRelativeUrl(url.pathname, url.search);
 	if (protocolRelativeGuard) return protocolRelativeGuard;
 	try {
@@ -109,7 +108,7 @@ async function handleRequest(request, env, platformCtx) {
 	const result = await (ctx ? runWithExecutionContext(ctx, handleFn) : handleFn());
 	if (result instanceof Response) {
 		let response = result;
-		const imageSignal = servesImages ? readImageOptimizationSignal(response) : null;
+		const imageSignal = assets ? readImageOptimizationSignal(response) : null;
 		if (imageSignal && assets) {
 			const { fetchSignalledPublicFile, serveWorkerImageOptimization } = await import("./worker-image-optimization.js");
 			response = await serveWorkerImageOptimization(request, imageSignal, __imageAllowedWidths, __imageConfig, {

package/dist/server/app-rsc-cache-busting.d.ts

@@ -78,6 +78,14 @@ export declare function createRscRequestHeaders(options?: CreateRscRequestHeader
  * their bytes can legitimately differ from the destination's full route.
  */
 export declare function canonicalizePrewarmableRscRequestHeaders(headers: Headers): boolean;
+/**
+ * Convert a search-param shell prefetch to the canonical navigation of its
+ * page. The shell renders the page with an empty query (app-page-dispatch.ts),
+ * which is what the query-free navigation renders, as Next.js's static
+ * prefetch of a page segment never varies on search params. The caller drops
+ * the query from the URL.
+ */
+export declare function canonicalizeDynamicShellRscRequestHeaders(headers: Headers): boolean;
 /**
  * Convert an ordinary loading-boundary prefetch to the shared loading-shell
  * variant. The payload is selected by the three retained mode headers; visible