vinext 1.4.1 → 1.4.3

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

@@ -14,5 +14,7 @@ export declare function handleApiRoute(runner: ModuleImporter, req: IncomingMess
   allowedRevalidateHeaderKeys?: readonly string[];
   trailingSlash?: boolean;
   skipTrailingSlashRedirect?: boolean;
+  /** Edge API request pathname, with any basePath the dev server stripped restored. */
+  requestPathname?: string;
 }): Promise<boolean>;
 //#endregion

package/dist/server/api-handler.js

@@ -1,4 +1,3 @@
-import { hasBasePath } from "../utils/base-path.js";
 import { matchRoute } from "../routing/pages-router.js";
 import "./server-globals.js";
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
@@ -94,7 +93,7 @@ function readEdgeRequestBody(req) {
 		req.on("error", (error) => controller.error(error));
 	} });
 }
-function createEdgeApiRequest(req, res, url, params, nextConfig) {
+function createEdgeApiRequest(req, res, url, params, requestPathname) {
 	const headers = new Headers();
 	for (const [name, value] of Object.entries(req.headers)) {
 		if (name.startsWith(":")) continue;
@@ -104,8 +103,7 @@ function createEdgeApiRequest(req, res, url, params, nextConfig) {
 	const proto = resolveRequestProtocol(req);
 	const host = resolveRequestHost(req, "localhost");
 	const requestUrl = new URL(req.url ?? url, `${proto}://${host}`);
-	const basePath = nextConfig?.basePath;
-	if (basePath && !hasBasePath(requestUrl.pathname, basePath)) requestUrl.pathname = `${basePath}${requestUrl.pathname}`;
+	if (requestPathname !== void 0) requestUrl.pathname = requestPathname;
 	const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
 	requestUrl.search = urlQueryToSearchParams(query).toString();
 	const signal = signalFromNodeResponse(res);
@@ -188,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");
@@ -210,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");
@@ -250,7 +252,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 	try {
 		const apiModule = await importModule(runner, route.filePath);
 		if (isEdgeApiRouteModule(apiModule)) {
-			const nextRequest = new NextRequest(createEdgeApiRequest(req, res, url, params, nextConfig), nextConfig ? { nextConfig: {
+			const nextRequest = new NextRequest(createEdgeApiRequest(req, res, url, params, nextConfig?.requestPathname), nextConfig ? { nextConfig: {
 				basePath: nextConfig.basePath,
 				i18n: nextConfig.i18n ?? void 0,
 				trailingSlash: nextConfig.trailingSlash,

package/dist/server/app-action-forwarding.js

@@ -6,6 +6,7 @@ import { RequestCookies, ResponseCookies } from "../shims/server.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { getSetCookieName } from "./cookie-utils.js";
 import "../shims/internal/cookies.js";
+import { isStreamedActionRedirectResponse, markStreamedActionRedirectResponse } from "./app-rsc-response-finalizer.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
 //#region src/server/app-action-forwarding.ts
 const ACTION_FORWARD_FORBIDDEN_HEADERS = /* @__PURE__ */ new Set([
@@ -71,11 +72,12 @@ function filterActionForwardResponse(response, sourceMiddlewareHeaders, sourceMi
 	for (const [key, value] of response.headers) if (!ACTION_FORWARD_FORBIDDEN_HEADERS.has(key.toLowerCase())) headers.set(key, value);
 	for (const setCookie of response.headers.getSetCookie()) headers.append("set-cookie", setCookie);
 	const preserveResponseStatus = response.headers.get("x-nextjs-action-not-found") === "1" || response.headers.has("x-action-redirect");
-	return new Response(response.body, {
+	const forwardedResponse = new Response(response.body, {
 		headers,
 		status: preserveResponseStatus ? response.status : sourceMiddlewareStatus ?? response.status,
 		statusText: response.statusText
 	});
+	return isStreamedActionRedirectResponse(response) ? markStreamedActionRedirectResponse(forwardedResponse) : forwardedResponse;
 }
 function emptyActionForwardResponse(middlewareContext) {
 	const headers = new Headers(middlewareContext.headers ?? void 0);

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";
@@ -23,16 +20,16 @@ import { navigationPlanner } from "./navigation-planner.js";
 import { decodeRedirectError, isRedirectError } from "../shims/navigation-errors.js";
 import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { getBfcacheIdMapContext, getNavigationContext, setNavigationContext } from "../shims/navigation-context-state.js";
-import { DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL, __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, deletePrefetchResponseSnapshot, disableNavigationResponsePrefetchCacheReuse, getClientNavigationRenderContext, getMountedSlotsHeader, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidateDynamicPrefetchCache, invalidatePrefetchCache, invalidateVisitedResponsePrefetches, parseRenderedPathAndSearchHeader, preloadHybridClientRouteOwner, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setPendingPathname, trackAppRouterNavigationInFlight, useRouter } from "../shims/navigation.js";
+import { DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL, __basePath, activateNavigationSnapshot, appRouterInstance, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, deletePrefetchResponseSnapshot, disableNavigationResponsePrefetchCacheReuse, getClientNavigationRenderContext, getMountedSlotsHeader, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidateDynamicPrefetchCache, invalidatePrefetchCache, invalidateVisitedResponsePrefetches, parseRenderedPathAndSearchHeader, preloadHybridClientRouteOwner, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setPendingPathname, trackAppRouterNavigationInFlight, useRouter } from "../shims/navigation.js";
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
 import { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal } from "./app-browser-stream.js";
 import { createMountedLayoutsHeader, holdsSkippedLayouts } from "./app-mounted-layouts.js";
-import { BfcacheIdentityMapContext, bindAppElementsRenderedSearch, setAppElementsRenderedSearch } from "../shims/slot.js";
+import { BfcacheIdentityMapContext, bindAppElementsRenderedSearch, isBfcacheIdentityRetained, setAppElementsRenderedSearch } from "../shims/slot.js";
 import { COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, isCacheRestorableAppPayloadMetadata, isCompleteAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl } from "./app-browser-state.js";
 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";
@@ -195,6 +192,12 @@ const RSC_HMR_SETTLE_DELAY_MS = 150;
 const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
 let latestRscHmrUpdateId = 0;
 let synchronousPopstateScrollRestoreNavigationId = null;
+let pendingHistoryRestoreCommit = null;
+function flushPendingHistoryRestoreCommit() {
+	const commit = pendingHistoryRestoreCommit;
+	pendingHistoryRestoreCommit = null;
+	commit?.();
+}
 function waitForRscHmrSettle(delayMs = RSC_HMR_SETTLE_DELAY_MS) {
 	return new Promise((resolve) => {
 		window.setTimeout(resolve, delayMs);
@@ -212,6 +215,10 @@ function restoreHistoryStateSnapshot(historyState, navId, onApprovedBeforeCommit
 				beforeCommit: () => {
 					onApprovedBeforeCommit?.();
 					beforeCommit();
+					if (!restoreCopiedExternalHistoryEntry) {
+						activateNavigationSnapshot();
+						pendingHistoryRestoreCommit = () => commitClientNavigationState(navId);
+					}
 				},
 				navId,
 				state,
@@ -223,7 +230,8 @@ function restoreHistoryStateSnapshot(historyState, navId, onApprovedBeforeCommit
 	clientNavigationCacheGeneration += 1;
 	revokeHistoryRestoreNavigationReuse(visitedResponseCache);
 	disableNavigationResponsePrefetchCacheReuse();
-	commitClientNavigationState(navId, { releaseSnapshot: false });
+	if (restoreCopiedExternalHistoryEntry) commitClientNavigationState(navId, { releaseSnapshot: false });
+	else flushPendingHistoryRestoreCommit();
 	return true;
 }
 function getBrowserRouterState() {
@@ -267,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,
@@ -471,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,
@@ -1083,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,
@@ -1184,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,
@@ -1393,7 +1383,10 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 								currentElements: navigationInitiationState.elements,
 								currentLayoutIds: navigationInitiationState.layoutIds,
 								currentParams: navigationInitiationState.navigationSnapshot.params,
+								isBfcacheIdentityRetained,
 								routeManifest,
+								shownElements: getBrowserRouterState().elements,
+								targetElements: optimisticPayload.elements,
 								targetRouteParams: optimisticPayload.routeParams,
 								targetUrlParts: optimisticPayload.urlParts,
 								template: optimisticPayload.template
@@ -1635,7 +1628,10 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 		discardPendingNavigation: () => {
 			if (browserNavigationController.discardPendingNavigation(historyController.readCurrentTreeSnapshot())) navigationAbortCoordinator.abortActive();
 		},
-		flushCommittingNavigationUrl: () => browserNavigationController.flushCommittingNavigationUrl()
+		flushCommittingNavigationUrl: () => {
+			flushPendingHistoryRestoreCommit();
+			browserNavigationController.flushCommittingNavigationUrl();
+		}
 	});
 	const handlePopstate = createPopstateRestoreHandler({
 		getActiveNavigationId: browserNavigationController.getActiveNavigationId.bind(browserNavigationController),

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-elements.d.ts

@@ -1,6 +1,9 @@
 import { APP_ARTIFACT_COMPATIBILITY_KEY, APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_DYNAMIC_STALE_TIME_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_SOURCE_PAGE_SEGMENTS_KEY, APP_STATIC_SIBLINGS_KEY, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementValue, AppElements, AppElementsBfcacheSegmentIdentities, AppElementsInterception, AppElementsSlotBinding, AppElementsWire, AppOutgoingElements, AppWireElements, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata } from "./app-elements-wire.js";
 //#region src/server/app-elements.d.ts
 export declare const APP_PREFETCH_LOADING_SHELL_MARKER_KEY = "__prefetchLoadingShell";
+type AppElementsStateKeyRebinder = (stateKey: string) => string;
+export declare function setOptimisticStateKeyRebinder(elements: Record<string, unknown>, rebind: AppElementsStateKeyRebinder): void;
+export declare function readOptimisticStateKeyRebinder(elements: AppElements): AppElementsStateKeyRebinder | null;
 /** Prefix of the element that streams a route's generateMetadata() tags in the body. */
 export declare const APP_STREAMING_METADATA_BODY_ID_PREFIX = "__vinext_streaming_metadata_body:";
 export declare function getMountedSlotIds(elements: AppElements): string[];

package/dist/server/app-elements.js

@@ -2,6 +2,19 @@ import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { APP_ARTIFACT_COMPATIBILITY_KEY, APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_DYNAMIC_STALE_TIME_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_SOURCE_PAGE_SEGMENTS_KEY, APP_STATIC_SIBLINGS_KEY, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata } from "./app-elements-wire.js";
 //#region src/server/app-elements.ts
 const APP_PREFETCH_LOADING_SHELL_MARKER_KEY = "__prefetchLoadingShell";
+/**
+* An optimistic shell's rebinder from the learned URL's segment state keys to
+* the target's. Only the browser sets it, on the elements it builds a shell
+* from, so it never reaches the wire.
+*/
+const APP_OPTIMISTIC_STATE_KEY_REBINDER_KEY = "__optimisticStateKeyRebinder";
+function setOptimisticStateKeyRebinder(elements, rebind) {
+	elements[APP_OPTIMISTIC_STATE_KEY_REBINDER_KEY] = rebind;
+}
+function readOptimisticStateKeyRebinder(elements) {
+	const rebind = Reflect.get(elements, APP_OPTIMISTIC_STATE_KEY_REBINDER_KEY);
+	return typeof rebind === "function" ? rebind : null;
+}
 /** Prefix of the element that streams a route's generateMetadata() tags in the body. */
 const APP_STREAMING_METADATA_BODY_ID_PREFIX = "__vinext_streaming_metadata_body:";
 function getMountedSlotIds(elements) {
@@ -18,4 +31,4 @@ function resolveVisitedResponseInterceptionContext(requestInterceptionContext, p
 	return payloadInterceptionContext ?? requestInterceptionContext;
 }
 //#endregion
-export { APP_ARTIFACT_COMPATIBILITY_KEY, APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_DYNAMIC_STALE_TIME_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_IDS_KEY, APP_PREFETCH_LOADING_SHELL_MARKER_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_SOURCE_PAGE_SEGMENTS_KEY, APP_STATIC_SIBLINGS_KEY, APP_STREAMING_METADATA_BODY_ID_PREFIX, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, getMountedSlotIds, getMountedSlotIdsHeader, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, resolveVisitedResponseInterceptionContext };
+export { APP_ARTIFACT_COMPATIBILITY_KEY, APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_DYNAMIC_STALE_TIME_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_IDS_KEY, APP_PREFETCH_LOADING_SHELL_MARKER_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_SOURCE_PAGE_SEGMENTS_KEY, APP_STATIC_SIBLINGS_KEY, APP_STREAMING_METADATA_BODY_ID_PREFIX, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, getMountedSlotIds, getMountedSlotIdsHeader, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, readOptimisticStateKeyRebinder, resolveVisitedResponseInterceptionContext, setOptimisticStateKeyRebinder };

package/dist/server/app-fallback-renderer.js

@@ -1,10 +1,10 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
 import { shareIsolatePromise } from "./isolate-shared-promise.js";
-import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
-import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { renderAppPageErrorBoundary, renderAppPageHttpAccessFallback } from "./app-page-boundary-render.js";
+import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
 import { DEFAULT_GLOBAL_NOT_FOUND_MODULE } from "./default-global-not-found-module.js";
 import { DEFAULT_NOT_FOUND_MODULE } from "./default-http-access-fallback-modules.js";
+import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 //#region src/server/app-fallback-renderer.ts
 const EMPTY_MW_CTX = {
 	headers: null,

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-optimistic-routing.d.ts

@@ -10,6 +10,8 @@ export type OptimisticRouteTemplate = {
   omittedBfcacheSegmentIds: readonly string[];
   omittedLayoutIds: readonly string[];
   pageElementIds: readonly string[];
+  /** The navigation params of the URL the template was learned from. */
+  params: Readonly<Record<string, string | string[]>>;
   routeId: string;
 };
 type OptimisticNavigationPayload = {
@@ -48,7 +50,7 @@ export declare function createOptimisticRouteTemplate(options: {
   mountedSlotsHeader: string | null;
   routeManifest: BrowserRouteManifest;
 }): OptimisticRouteTemplate | null;
-export declare function createOptimisticRouteElements(template: OptimisticRouteTemplate): AppElements;
+export declare function createOptimisticRouteElements(template: OptimisticRouteTemplate, params?: Readonly<Record<string, string | string[]>>): AppElements;
 /**
  * The optimistic shell reveals the prefetch's streamed metadata, such as its
  * title. React won't hide revealed content again in a transition, so while the
@@ -77,7 +79,16 @@ export declare function canCommitOptimisticRouteTemplate(options: {
   currentElements: AppElements;
   currentLayoutIds: readonly string[];
   currentParams: Readonly<Record<string, string | string[]>>;
+  /** Whether a hidden BFCache entry retains a segment identity. */
+  isBfcacheIdentityRetained?: (identity: string) => boolean;
   routeManifest: BrowserRouteManifest;
+  /**
+   * The elements on screen, when a shell earlier in this navigation replaced
+   * the current ones. Defaults to `currentElements`.
+   */
+  shownElements?: AppElements;
+  /** The shell's elements for the target. */
+  targetElements?: AppElements;
   targetRouteParams: Readonly<Record<string, string | string[]>>;
   targetUrlParts: readonly string[];
   template: OptimisticRouteTemplate;

package/dist/server/app-optimistic-routing.js

@@ -4,10 +4,10 @@ import { decodeMatchedParams, splitPathnameForRouteMatch } from "../routing/util
 import { extractRawRoutePatternParams, matchRoutePattern } from "../routing/route-pattern.js";
 import { buildOptimisticRouteTrie, matchOptimisticRouteTrie } from "../routing/optimistic-route-trie.js";
 import { stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
-import { AppElementsWire } from "./app-elements-wire.js";
-import "./app-elements.js";
+import { APP_BFCACHE_SEGMENT_IDENTITIES_KEY, AppElementsWire } from "./app-elements-wire.js";
+import { setOptimisticStateKeyRebinder } from "./app-elements.js";
 import { createNestedBfcacheSlotSegmentId, deriveBfcacheSegmentIdentity, isNestedBfcacheSlotSegmentId } from "./bfcache-identity.js";
-import { canonicalizeAppPageParams, resolveAppPagePatternStateKey, resolveAppPageSemanticSegmentStateKey } from "./app-page-segment-state.js";
+import { APP_PAGE_DEFAULT_SEGMENT_KEY, APP_PAGE_SEGMENT_KEY, canonicalizeAppPageParams, createAppPageSegmentStateKeyRebinder, resolveAppPagePatternStateKey, resolveAppPageSemanticSegmentStateKey } from "./app-page-segment-state.js";
 import { Suspense, createElement, isValidElement } from "react";
 //#region src/server/app-optimistic-routing.ts
 const routeTrieCache = /* @__PURE__ */ new WeakMap();
@@ -114,6 +114,18 @@ function resolveTargetBfcacheSegmentIdentity(options) {
 		const segmentParams = binding.state === "active" && binding.slotPatternParts !== void 0 && binding.slotPatternParts.length > 0 && !binding.slotParamNames?.every((name) => routeParamNames.has(name)) ? matchRoutePattern(options.targetUrlParts, binding.slotPatternParts) ?? options.targetRouteParams : options.targetRouteParams;
 		const ownerLayout = binding.ownerLayoutId ? options.routeManifest.segmentGraph.layouts.get(binding.ownerLayoutId) : void 0;
 		const ownerStateKey = ownerLayout ? resolveAppPagePatternStateKey(ownerLayout.patternParts, options.targetRouteParams) : "";
+		const deriveLevelIdentity = (segmentKeys) => {
+			const identityKey = JSON.stringify(segmentKeys);
+			return deriveBfcacheSegmentIdentity({
+				activeRouteGraphId: null,
+				boundSegmentKey: ownerStateKey ? JSON.stringify([ownerStateKey, identityKey]) : identityKey,
+				interceptionTargetRouteGraphId: null,
+				kind: "slot",
+				ownerLayoutGraphId: binding.ownerLayoutId,
+				slotGraphId: binding.slotId,
+				state: binding.state
+			});
+		};
 		const boundSegmentKeys = [];
 		let level = 0;
 		for (const segment of binding.routeSegments ?? []) {
@@ -125,17 +137,9 @@ function resolveTargetBfcacheSegmentIdentity(options) {
 				segment
 			}, segmentParams));
 			if (createNestedBfcacheSlotSegmentId(binding.slotId, level) !== options.segmentId) continue;
-			const identityKey = JSON.stringify(boundSegmentKeys);
-			return deriveBfcacheSegmentIdentity({
-				activeRouteGraphId: null,
-				boundSegmentKey: ownerStateKey ? JSON.stringify([ownerStateKey, identityKey]) : identityKey,
-				interceptionTargetRouteGraphId: null,
-				kind: "slot",
-				ownerLayoutGraphId: binding.ownerLayoutId,
-				slotGraphId: binding.slotId,
-				state: binding.state
-			});
+			return deriveLevelIdentity(boundSegmentKeys);
 		}
+		if (level > 0 && createNestedBfcacheSlotSegmentId(binding.slotId, level + 1) === options.segmentId) return deriveLevelIdentity([...boundSegmentKeys, binding.state === "default" ? APP_PAGE_DEFAULT_SEGMENT_KEY : APP_PAGE_SEGMENT_KEY]);
 		if (level === 0 && createNestedBfcacheSlotSegmentId(binding.slotId, 1) === options.segmentId) return deriveBfcacheSegmentIdentity({
 			activeRouteGraphId: null,
 			boundSegmentKey: ownerStateKey ? JSON.stringify([ownerStateKey, ""]) : "",
@@ -188,18 +192,31 @@ function createOptimisticRouteTemplate(options) {
 	if (options.allowLoadingShell && (routeElement === void 0 || routeElement === null)) return null;
 	const pageElementIds = getPageElementIds(options.elements, match.route);
 	if (pageElementIds.length === 0) return null;
+	const urlParts = hrefToRouteParts(options.href, options.basePath);
+	if (urlParts === null) return null;
 	return {
 		elements: options.elements,
 		mountedSlotsHeader: options.mountedSlotsHeader,
 		omittedBfcacheSegmentIds: options.elements["__prefetchLoadingShell"] === "LoadingBoundary" ? getOmittedBfcacheSegmentIds(options.elements) : [],
 		omittedLayoutIds: options.elements["__prefetchLoadingShell"] === "LoadingBoundary" ? metadata.layoutIds.filter((layoutId) => !Object.hasOwn(options.elements, layoutId)) : [],
 		pageElementIds,
+		params: resolveOptimisticNavigationParams({
+			match,
+			rawUrlParts: urlParts.raw,
+			routeManifest: options.routeManifest,
+			urlParts: urlParts.normalized
+		}).navigationParams,
 		routeId: match.route.id
 	};
 }
-function createOptimisticRouteElements(template) {
+function createOptimisticRouteElements(template, params = template.params) {
 	const elements = { ...template.elements };
 	for (const pageElementId of template.pageElementIds) elements[pageElementId] = createElement(OptimisticRouteSegment);
+	const reify = createAppPageSegmentStateKeyRebinder(template.params, params);
+	if (reify === null) return elements;
+	setOptimisticStateKeyRebinder(elements, reify);
+	const identities = AppElementsWire.readMetadata(template.elements).bfcacheSegmentIdentities;
+	if (Object.keys(identities).length > 0) elements[APP_BFCACHE_SEGMENT_IDENTITIES_KEY] = Object.fromEntries(Object.entries(identities).map(([id, identity]) => [id, reify(identity)]));
 	return elements;
 }
 function findStreamingMetadataBody(elements) {
@@ -244,9 +261,14 @@ function keepOptimisticStreamingMetadata(elements, optimisticElements, navigatio
 * loading boundary does not re-trigger.
 */
 function canCommitOptimisticRouteTemplate(options) {
+	const currentIdentities = AppElementsWire.readMetadata(options.currentElements).bfcacheSegmentIdentities;
+	const { isBfcacheIdentityRetained, targetElements } = options;
+	if (isBfcacheIdentityRetained && targetElements) {
+		const shownIdentities = new Set(Object.values(options.shownElements ? AppElementsWire.readMetadata(options.shownElements).bfcacheSegmentIdentities : currentIdentities));
+		for (const identity of Object.values(AppElementsWire.readMetadata(targetElements).bfcacheSegmentIdentities)) if (!shownIdentities.has(identity) && isBfcacheIdentityRetained(identity)) return false;
+	}
 	if (options.template.omittedLayoutIds.length === 0 && options.template.omittedBfcacheSegmentIds.length === 0) return true;
 	const currentLayoutIds = new Set(options.currentLayoutIds);
-	const currentIdentities = AppElementsWire.readMetadata(options.currentElements).bfcacheSegmentIdentities;
 	for (const layoutId of options.template.omittedLayoutIds) {
 		if (!currentLayoutIds.has(layoutId)) continue;
 		if (!Object.hasOwn(options.currentElements, layoutId)) continue;
@@ -302,7 +324,7 @@ function resolveOptimisticNavigationPayload(options) {
 		urlParts: urlParts.normalized
 	});
 	return {
-		elements: createOptimisticRouteElements(template),
+		elements: createOptimisticRouteElements(template, navigationParams),
 		params: navigationParams,
 		routeParams,
 		template,

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

@@ -20,9 +20,9 @@ import { hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRou
 import { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryModule, wrapAppPageBoundaryElement } from "./app-page-boundary.js";
 import { createRouteNotFoundHeadPlanOptions, recoverAppPageRouteHead, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport } from "./app-page-http-access-fallback-metadata.js";
 import "./app-rsc-route-matching.js";
-import { createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage } from "./app-page-route-wiring.js";
-import { resolveSlotParamOverrides } from "./app-page-element-builder.js";
+import { resolveSlotParamOverrides } from "./app-page-navigation-params.js";
 import { createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlResponse } from "./app-page-stream.js";
+import { createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage } from "./app-page-route-wiring.js";
 import { Fragment, Suspense, createElement } from "react";
 //#region src/server/app-page-boundary-render.ts
 async function AppPageBoundaryStreamedMetadata(props) {
@@ -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
 				})
 			});