vinext 1.4.2 → 1.4.4

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-browser-visible-commit.js

@@ -1,8 +1,8 @@
 import { AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { createBfcacheSegmentIdentityMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 import { NavigationTraceReasonCodes, NavigationTraceTransactionCodes, createNavigationTrace, prependNavigationTraceEntry } from "./navigation-trace.js";
 import { mergeElements } from "../shims/slot.js";
+import { createBfcacheSegmentIdentityMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 import { createPendingNavigationCommit, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
 import { resolveAppPageRouteStateKey } from "./app-page-segment-state.js";
 //#region src/server/app-browser-visible-commit.ts

package/dist/server/app-history-state.js

@@ -1,7 +1,7 @@
+import { isNonNegativeSafeInteger } from "../utils/number.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { isBfcacheSegmentId } from "./app-bfcache-id.js";
-import { isNonNegativeSafeInteger } from "../utils/number.js";
 //#region src/server/app-history-state.ts
 const VINEXT_PREVIOUS_NEXT_URL_HISTORY_STATE_KEY = "__vinext_previousNextUrl";
 const VINEXT_HISTORY_INDEX_HISTORY_STATE_KEY = "__vinext_historyIndex";

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

@@ -3,14 +3,14 @@ import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
 import { isRenderDynamicLatched, isStaticGenerationAccessError } from "../shims/internal/headers-state.js";
 import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
+import { withUseCacheLayoutMarker } from "../shims/internal/app-page-props-cache-key.js";
+import { rewriteClientHookError } from "../shims/client-hook-error.js";
 import { createArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { ErrorBoundary, GlobalErrorBoundary, SerializedErrorBoundary } from "../shims/error-boundary.js";
-import { rewriteClientHookError } from "../shims/client-hook-error.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
-import { withUseCacheLayoutMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { MetadataHead, ViewportHead } from "../shims/metadata.js";
 import { buildRscRedirectFlightStream } from "./app-rsc-redirect-flight.js";
 import { bufferAppPageBinaryStream, buildAppPageSpecialErrorResponse, resolveAppPageSpecialError } from "./app-page-execution.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

@@ -1,11 +1,12 @@
 import { isPromiseLike } from "../utils/promise.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION } from "./app-rsc-render-mode.js";
+import { makeThenableParams } from "../shims/thenable-params.js";
+import { withUseCacheLayoutMarker, withUseCachePageMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey, resolveAppPageSemanticSegmentStateKey } from "./app-page-segment-state.js";
+import { ClientPageRoot } from "../shims/client-page-root.js";
 import { ErrorBoundary, ForbiddenBoundary, NotFoundBoundary, UnauthorizedBoundary } from "../shims/error-boundary.js";
-import { withUseCacheLayoutMarker, withUseCachePageMarker } from "../shims/internal/app-page-props-cache-key.js";
-import { makeThenableParams } from "../shims/thenable-params.js";
+import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey, resolveAppPageSemanticSegmentStateKey } from "./app-page-segment-state.js";
 import { tagAppPagePageError, tagAppPageSlotError } from "./app-page-execution.js";
 import { createAppPageMetadataSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
 import { resolveAppPageBranchParams } from "./app-page-params.js";
@@ -19,7 +20,6 @@ import { resolveAppPageModuleTraceSegment, traceCreateComponentTree, traceGetLay
 import { buildAppPageElements, createAppPageSourcePage, createAppPageTreePath, resolveAppPageLoadingModuleAtOrAbove } from "./app-page-route-wiring.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
-import { ClientPageRoot } from "../shims/client-page-root.js";
 import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
 import { Fragment, Suspense, cache, createElement } from "react";
 //#region src/server/app-page-element-builder.ts
@@ -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-render.js

@@ -17,11 +17,11 @@ import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./
 import { copyLinkHeaderProvenance, getFrameworkLinkHeader } from "./app-response-header-provenance.js";
 import { traceResponseStartWithCompletion } from "./response-start-tracing.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { isBailoutToCSRError } from "../shims/navigation-errors.js";
 import { createArtifactCompatibilityEnvelope, createArtifactCompatibilityGraphVersion } from "./artifact-compatibility.js";
 import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { appendRscCompletionMetadata } from "./rsc-completion-metadata.js";
-import { isBailoutToCSRError } from "../shims/navigation-errors.js";
 import { applyClientStaleTimeHeader, applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy, resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
 import { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";

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

@@ -1,24 +1,24 @@
 import { APP_RSC_RENDER_MODE_PREFETCH_EMPTY, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "./app-rsc-render-mode.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { createInlineScriptTag, escapeHtmlAttr } from "./html.js";
+import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
+import { withUseCacheLayoutMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import { APP_PREFETCH_LOADING_SHELL_MARKER_KEY, APP_STREAMING_METADATA_BODY_ID_PREFIX } from "./app-elements.js";
 import { createBfcacheChildSegmentStateKey } from "./bfcache-identity.js";
-import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
-import { hashMountedLayoutIdentity } from "./app-mounted-layouts.js";
 import { BfcacheChildrenBoundary, BfcacheSegmentBoundary, Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
-import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPageChildSegments, resolveAppPageSegmentStateKey, resolveAppPageTemplateStateKey } from "./app-page-segment-state.js";
+import DefaultForbidden from "../shims/default-forbidden.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
+import DefaultNotFound from "../shims/default-not-found.js";
+import DefaultUnauthorized from "../shims/default-unauthorized.js";
 import { ErrorBoundary, ForbiddenBoundary, GlobalErrorBoundary, HttpAccessFallbackPassthrough, NotFoundBoundary, RedirectBoundary, UnauthorizedBoundary } from "../shims/error-boundary.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
-import { withUseCacheLayoutMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { MetadataHead, ViewportHead, renderMetadataToHtml } from "../shims/metadata.js";
+import { StreamedIconsInsertion } from "../shims/streamed-icons.js";
+import { hashMountedLayoutIdentity } from "./app-mounted-layouts.js";
+import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPageChildSegments, resolveAppPageSegmentStateKey, resolveAppPageTemplateStateKey } from "./app-page-segment-state.js";
 import { APP_PAGE_NOT_FOUND_BOUNDARY_ID, tagAppPageLayoutError, tagAppPageSlotError } from "./app-page-execution.js";
 import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
-import DefaultForbidden from "../shims/default-forbidden.js";
-import DefaultNotFound from "../shims/default-not-found.js";
-import DefaultUnauthorized from "../shims/default-unauthorized.js";
-import { StreamedIconsInsertion } from "../shims/streamed-icons.js";
 import { createAppRenderDependency, invokeAppComponentMappingErrors, isReactOwnedAppComponent, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier } from "./app-render-dependency.js";
 import { createAppPageLayoutGate, registerAppPageLayoutGate } from "./app-page-layout-gate.js";
 import { probeReactServerSubtree } from "./app-page-probe.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-context.js

@@ -1,7 +1,7 @@
 import { setHeadersContext } from "../shims/headers.js";
+import { setRootParams } from "../shims/root-params.js";
 import { setNavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation-server.js";
-import { setRootParams } from "../shims/root-params.js";
 //#region src/server/app-request-context.ts
 /**
 * Set navigation context in the ALS-backed store. "use client" components

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-route-handler-dispatch.js

@@ -14,9 +14,9 @@ import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setC
 import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 import { traceResponseStart } from "./response-start-tracing.js";
 import { applyRouteHandlerMiddlewareContext, finalizeRouteHandlerResponse } from "./app-route-handler-response.js";
+import { makeThenableParams } from "../shims/thenable-params.js";
 import { setNavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation.js";
-import { makeThenableParams } from "../shims/thenable-params.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";

package/dist/server/app-route-handler-execution.js

@@ -10,8 +10,8 @@ import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
 import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
-import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { runWithRootParamsUsage } from "../shims/root-params.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldCompleteAppRouteHandlerResponse, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";

package/dist/server/app-route-handler-response.d.ts

@@ -17,6 +17,7 @@ type FinalizeRouteHandlerResponseOptions = {
   draftCookie?: string | null;
   isHead: boolean;
 };
+export declare function stripRouteHandlerFramingHeaders(response: Response): Response;
 export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: MiddlewareResponseMergeOptions & {
   appendResponseLink?: boolean;
 }): Response;

package/dist/server/app-route-handler-response.js

@@ -1,3 +1,4 @@
+import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
 import "../utils/protocol-headers.js";
 import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER } from "./headers.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
@@ -11,6 +12,28 @@ import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-route-handler-response.ts
 const APP_ROUTE_REWRITE_ERROR = "NextResponse.rewrite() was used in a app route handler, this is not currently supported. Please remove the invocation to continue.";
 const APP_ROUTE_NEXT_ERROR = "NextResponse.next() was used in a app route handler, this is not supported. See here for more info: https://nextjs.org/docs/messages/next-response-next-in-app-route-handler";
+const ROUTE_HANDLER_FRAMING_HEADERS = [
+	"content-length",
+	"content-encoding",
+	"transfer-encoding"
+];
+function shouldDropRouteHandlerFramingHeaders(headers) {
+	if ("WebSocketPair" in globalThis) return false;
+	return ROUTE_HANDLER_FRAMING_HEADERS.some((name) => headers.has(name));
+}
+function deleteRouteHandlerFramingHeaders(headers) {
+	for (const name of ROUTE_HANDLER_FRAMING_HEADERS) headers.delete(name);
+}
+function stripRouteHandlerFramingHeaders(response) {
+	if (!shouldDropRouteHandlerFramingHeaders(response.headers)) return response;
+	const headers = new Headers(response.headers);
+	deleteRouteHandlerFramingHeaders(headers);
+	return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	}));
+}
 function hasMiddlewareHeader(headers) {
 	for (const key of headers.keys()) if (key.startsWith("x-middleware-")) return true;
 	return false;
@@ -42,6 +65,7 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 	else headers.set(key, value);
 	headers.delete(NEXT_CACHE_TAGS_HEADER);
 	headers.delete(VINEXT_METADATA_ROUTE_CACHE_HEADER);
+	if (shouldDropRouteHandlerFramingHeaders(headers)) deleteRouteHandlerFramingHeaders(headers);
 	setCacheStateHeaders(headers, options.cacheState);
 	const { cacheControl } = decideIsr({
 		cacheState: options.cacheState,
@@ -152,8 +176,9 @@ async function buildAppRouteCacheValue(response, browserCacheControl) {
 }
 function finalizeRouteHandlerResponse(response, options) {
 	const { pendingCookies, draftCookie, isHead } = options;
-	if (pendingCookies.length === 0 && !draftCookie && !isHead && !hasMiddlewareHeader(response.headers)) return response;
+	if (pendingCookies.length === 0 && !draftCookie && !isHead && !hasMiddlewareHeader(response.headers) && !shouldDropRouteHandlerFramingHeaders(response.headers)) return response;
 	const headers = new Headers(response.headers);
+	if (shouldDropRouteHandlerFramingHeaders(headers)) deleteRouteHandlerFramingHeaders(headers);
 	processMiddlewareHeaders(headers);
 	applyMutableCookieFallbacks(headers, pendingCookies);
 	if (draftCookie) headers.append("Set-Cookie", draftCookie);
@@ -164,4 +189,4 @@ function finalizeRouteHandlerResponse(response, options) {
 	});
 }
 //#endregion
-export { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss };
+export { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss, stripRouteHandlerFramingHeaders };

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

package/dist/server/app-rsc-cache-busting.js

@@ -199,6 +199,18 @@ function canonicalizePrewarmableRscRequestHeaders(headers) {
 	return true;
 }
 /**
+* 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.
+*/
+function canonicalizeDynamicShellRscRequestHeaders(headers) {
+	if (headers.get("X-Vinext-Rsc-Render-Mode") !== "prefetch-dynamic-shell" || headers.has("X-Vinext-Interception-Context") || headers.has("X-Vinext-Interception-Id") || headers.has("X-Vinext-Mounted-Slots")) return false;
+	headers.delete(VINEXT_RSC_RENDER_MODE_HEADER);
+	return canonicalizePrewarmableRscRequestHeaders(headers);
+}
+/**
 * Convert an ordinary loading-boundary prefetch to the shared loading-shell
 * variant. The payload is selected by the three retained mode headers; visible
 * router state is transport context and must not fragment the shared response.
@@ -285,4 +297,4 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	});
 }
 //#endregion
-export { VINEXT_RSC_BUILD_ID_HEADER, VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, computeRscCacheBustingSearchParam, createCanonicalLoadingShellRscRequestHeaders, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, formatRscRequestPath, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, keepOnlyValidatedRscCacheBustingSearchParam, parseRscRequestPath, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, toPathAbsolutePathname };
+export { VINEXT_RSC_BUILD_ID_HEADER, VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, canonicalizeDynamicShellRscRequestHeaders, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, computeRscCacheBustingSearchParam, createCanonicalLoadingShellRscRequestHeaders, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, formatRscRequestPath, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, keepOnlyValidatedRscCacheBustingSearchParam, parseRscRequestPath, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, toPathAbsolutePathname };

package/dist/server/app-rsc-combined-handler.js

@@ -1,13 +1,14 @@
 import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createAppRscRequestHandler } from "./app-rsc-handler.js";
+import { resolveSrvxMiddlewareOrigin } from "./srvx-middleware-origin.js";
 //#region src/server/app-rsc-combined-handler.ts
 /** Combined request/response handler used by default single-stage App entries. */
 function createAppRscHandler(options) {
 	const appRscRequestHandler = createAppRscRequestHandler(options);
 	const appRscHandler = (request, ctx, ...rest) => {
 		if (ctx != null || getRequestExecutionContext()) return appRscRequestHandler(request, ctx, ...rest);
-		const executionContext = createWorkerRevalidationContext(void 0, (internalRequest, internalCtx) => runWithExecutionContext(internalCtx, () => appRscRequestHandler(internalRequest, internalCtx)), "node");
+		const executionContext = createWorkerRevalidationContext({ middlewareOrigin: resolveSrvxMiddlewareOrigin(request) }, (internalRequest, internalCtx) => runWithExecutionContext(internalCtx, () => appRscRequestHandler(internalRequest, internalCtx)), "node");
 		return runWithExecutionContext(executionContext, () => appRscRequestHandler(request, ctx, ...rest));
 	};
 	return Object.assign(appRscHandler, { handleResponseStage(request, ctx, props, stageOptions) {