vinext 0.1.0 → 0.1.2

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

@@ -1,7 +1,7 @@
 //#region src/server/app-browser-rsc-redirect.d.ts
-declare const MAX_RSC_REDIRECT_DEPTH = 10;
 type RscRedirectHistoryUpdateMode = "push" | "replace" | undefined;
 type RscRedirectLifecycleDecision = {
+  href: string;
   kind: "no-redirect";
 } | {
   href: string;
@@ -24,5 +24,14 @@ declare function resolveRscRedirectLifecycleHop(options: {
   requestPreviousNextUrl: string | null;
   responseUrl: string;
 }): RscRedirectLifecycleDecision;
+declare function resolveStreamedRscRedirectLifecycleHop(options: {
+  currentHref: string;
+  historyUpdateMode: Exclude<RscRedirectHistoryUpdateMode, undefined>;
+  maxRedirectDepth?: number;
+  origin: string;
+  redirectDepth: number;
+  requestPreviousNextUrl: string | null;
+  streamedRedirectTarget: string;
+}): RscRedirectLifecycleDecision;
 //#endregion
-export { MAX_RSC_REDIRECT_DEPTH, resolveRscRedirectLifecycleHop };
+export { resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop };

package/dist/server/app-browser-rsc-redirect.js

@@ -6,17 +6,23 @@ function toVisibleAppHref(href, origin) {
 	stripRscCacheBustingSearchParam(url);
 	return `${stripRscSuffix(url.pathname)}${url.search}${url.hash}`;
 }
-function resolveRscRedirectLifecycleHop(options) {
-	const responseUrl = new URL(options.responseUrl, options.origin);
-	if (responseUrl.origin !== options.origin) return {
-		href: responseUrl.href,
+function toStreamedRedirectVisibleAppHref(href, origin) {
+	const url = new URL(href, origin);
+	return `${url.pathname}${url.search}${url.hash}`;
+}
+function resolveRedirectLifecycleHopFromTarget(options) {
+	if (options.targetUrl.origin !== options.origin) return {
+		href: options.targetUrl.href,
 		kind: "terminal-hard-navigation",
 		reason: "externalRedirect",
 		redirectDepth: options.redirectDepth
 	};
-	const redirectedHref = resolveHardNavigationTargetFromRscResponse(responseUrl.href, options.currentHref, options.origin);
-	if (redirectedHref === toVisibleAppHref(options.currentHref, options.origin)) return { kind: "no-redirect" };
-	const maxRedirectDepth = options.maxRedirectDepth ?? 10;
+	const redirectedHref = options.redirectedHref;
+	if (redirectedHref === toVisibleAppHref(options.currentHref, options.origin)) return {
+		href: redirectedHref,
+		kind: "no-redirect"
+	};
+	const maxRedirectDepth = options.maxRedirectDepth ?? MAX_RSC_REDIRECT_DEPTH;
 	if (options.redirectDepth >= maxRedirectDepth) return {
 		href: redirectedHref,
 		kind: "terminal-hard-navigation",
@@ -31,5 +37,21 @@ function resolveRscRedirectLifecycleHop(options) {
 		redirectDepth: options.redirectDepth + 1
 	};
 }
+function resolveRscRedirectLifecycleHop(options) {
+	const responseUrl = new URL(options.responseUrl, options.origin);
+	return resolveRedirectLifecycleHopFromTarget({
+		...options,
+		redirectedHref: resolveHardNavigationTargetFromRscResponse(responseUrl.href, options.currentHref, options.origin),
+		targetUrl: responseUrl
+	});
+}
+function resolveStreamedRscRedirectLifecycleHop(options) {
+	const streamedRedirectUrl = new URL(options.streamedRedirectTarget, options.origin);
+	return resolveRedirectLifecycleHopFromTarget({
+		...options,
+		redirectedHref: toStreamedRedirectVisibleAppHref(options.streamedRedirectTarget, options.origin),
+		targetUrl: streamedRedirectUrl
+	});
+}
 //#endregion
-export { MAX_RSC_REDIRECT_DEPTH, resolveRscRedirectLifecycleHop };
+export { resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop };

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

@@ -49,6 +49,7 @@ type AppRouterAction = {
   previousNextUrl: string | null;
   renderId: number;
   rootLayoutTreePath: string | null;
+  reuseCurrentBfcacheIds: boolean;
   routeId: string;
   skippedLayoutIds: readonly string[];
   slotBindings: readonly AppElementsSlotBinding[];
@@ -102,6 +103,7 @@ declare function createNextBfcacheIdMap(options: {
   elements: AppElements;
   nextPathname: string;
   restored?: BfcacheIdMap | null;
+  reuseCurrent?: boolean;
 }): BfcacheIdMap;
 declare function preserveBfcacheIdsForMergedElements(options: {
   elements: AppElements;
@@ -150,6 +152,7 @@ declare function createPendingNavigationCommit(options: {
   previousNextUrl?: string | null;
   renderId: number;
   restoredBfcacheIds?: BfcacheIdMap | null;
+  reuseCurrentBfcacheIds?: boolean;
   type: "navigate" | "replace" | "traverse";
 }): Promise<PendingNavigationCommit>;
 //#endregion

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

@@ -7,9 +7,10 @@ import { getMountedSlotIds, getMountedSlotIdsHeader } from "./app-elements.js";
 import "./app-bfcache-id.js";
 import { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 import { createRscRequestHeaders } from "./app-rsc-cache-busting.js";
-import { createCacheEntryReuseProof } from "./cache-proof.js";
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts } from "./navigation-planner.js";
+import { createSnapshotPathAndSearch } from "../shims/navigation.js";
+import { createCacheEntryReuseProof } from "./cache-proof.js";
 //#region src/server/app-browser-state.ts
 const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "fresh" };
 const VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "visited-cache" };
@@ -99,7 +100,8 @@ function createBfcacheSegmentStateKeyMap(options) {
 	return stateKeys;
 }
 function createNextBfcacheIdMap(options) {
-	for (const value of Object.values(options.current)) rememberBfcacheId(value);
+	const current = options.reuseCurrent === false ? {} : options.current;
+	for (const value of Object.values(current)) rememberBfcacheId(value);
 	for (const value of Object.values(options.restored ?? {})) rememberBfcacheId(value);
 	const currentMetadata = readAppElementsMetadata(options.currentElements);
 	const nextMetadata = readAppElementsMetadata(options.elements);
@@ -113,7 +115,7 @@ function createNextBfcacheIdMap(options) {
 		}) === createBfcacheSegmentIdentity(id, {
 			metadata: nextMetadata,
 			pathname: nextPathname
-		}) ? options.current[id] : void 0;
+		}) ? current[id] : void 0;
 		const value = options.restored?.[id] ?? currentValue ?? mintBfcacheId();
 		ids[id] = value;
 		rememberBfcacheId(value);
@@ -221,10 +223,6 @@ function createPendingNavigationTraceFields(options) {
 		...options.targetHref !== void 0 ? { targetHref: options.targetHref } : {}
 	};
 }
-function createNavigationSnapshotUrl(snapshot) {
-	const query = snapshot.searchParams.toString();
-	return query === "" ? snapshot.pathname : `${snapshot.pathname}?${query}`;
-}
 function createMountedParallelSlotSnapshots(elements) {
 	const snapshots = [];
 	for (const slotId of getMountedSlotIds(elements)) {
@@ -238,7 +236,7 @@ function createMountedParallelSlotSnapshots(elements) {
 	return snapshots;
 }
 function createVisibleRouteSnapshot(state) {
-	const displayUrl = createNavigationSnapshotUrl(state.navigationSnapshot);
+	const displayUrl = createSnapshotPathAndSearch(state.navigationSnapshot);
 	const matchedUrl = normalizeNavigationSnapshotMatchedUrl(state.navigationSnapshot.pathname);
 	return {
 		displayUrl,
@@ -256,7 +254,7 @@ function createVisibleRouteSnapshot(state) {
 	};
 }
 function createPendingRouteSnapshot(pending) {
-	const displayUrl = createNavigationSnapshotUrl(pending.action.navigationSnapshot);
+	const displayUrl = createSnapshotPathAndSearch(pending.action.navigationSnapshot);
 	const matchedUrl = normalizeNavigationSnapshotMatchedUrl(pending.action.navigationSnapshot.pathname);
 	return {
 		displayUrl,
@@ -396,7 +394,8 @@ async function createPendingNavigationCommit(options) {
 				currentPathname: options.currentState.navigationSnapshot.pathname,
 				elements,
 				nextPathname: options.navigationSnapshot.pathname,
-				restored: options.restoredBfcacheIds
+				restored: options.restoredBfcacheIds,
+				reuseCurrent: options.reuseCurrentBfcacheIds
 			}),
 			...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
 			elements,
@@ -414,6 +413,7 @@ async function createPendingNavigationCommit(options) {
 			previousNextUrl,
 			renderId: options.renderId,
 			rootLayoutTreePath: metadata.rootLayoutTreePath,
+			reuseCurrentBfcacheIds: options.reuseCurrentBfcacheIds ?? true,
 			routeId: metadata.routeId,
 			skippedLayoutIds: metadata.skippedLayoutIds,
 			type: options.type

package/dist/server/app-browser-visible-commit.js

@@ -1,7 +1,7 @@
 import { normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { mergeElements } from "../shims/slot.js";
 import { NavigationTraceReasonCodes, NavigationTraceTransactionCodes, createNavigationTrace, prependNavigationTraceEntry } from "./navigation-trace.js";
+import { mergeElements } from "../shims/slot.js";
 import { createPendingNavigationCommit, preserveBfcacheIdsForMergedElements, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
 //#region src/server/app-browser-visible-commit.ts
 const approvedVisibleCommitBrand = Symbol("ApprovedVisibleCommit");
@@ -56,29 +56,31 @@ function reduceApprovedVisibleCommitState(state, commit) {
 	switch (action.type) {
 		case "traverse":
 		case "navigate": {
+			const preserveElementIds = action.reuseCurrentBfcacheIds ? commit.decision.preserveElementIds : [];
+			const preservePreviousSlotIds = action.reuseCurrentBfcacheIds ? commit.decision.preservePreviousSlotIds : [];
 			const mergedElements = mergeElements(state.elements, action.elements, {
-				clearAbsentSlots: action.type === "traverse",
-				preserveAbsentSlots: commit.decision.preserveAbsentSlots,
-				preserveElementIds: commit.decision.preserveElementIds,
-				preservePreviousSlotIds: commit.decision.preservePreviousSlotIds
+				clearAbsentSlots: action.type === "traverse" || !action.reuseCurrentBfcacheIds,
+				preserveAbsentSlots: action.reuseCurrentBfcacheIds && commit.decision.preserveAbsentSlots,
+				preserveElementIds,
+				preservePreviousSlotIds
 			});
 			return commitVisibleRouterState(state, {
 				bfcacheIds: preserveBfcacheIdsForMergedElements({
 					elements: mergedElements,
 					next: action.bfcacheIds,
-					previous: state.bfcacheIds
+					previous: action.reuseCurrentBfcacheIds ? state.bfcacheIds : {}
 				}),
 				elements: mergedElements,
 				interception: action.interception,
 				interceptionContext: action.interceptionContext,
-				layoutFlags: mergeLayoutFlags(state.layoutFlags, action.layoutFlags, commit.decision.preserveElementIds),
+				layoutFlags: mergeLayoutFlags(state.layoutFlags, action.layoutFlags, preserveElementIds),
 				layoutIds: action.layoutIds,
 				navigationSnapshot: action.navigationSnapshot,
 				previousNextUrl: action.previousNextUrl,
 				renderId: action.renderId,
 				rootLayoutTreePath: action.rootLayoutTreePath,
 				routeId: action.routeId,
-				slotBindings: mergeSlotBindings(state.slotBindings, action.slotBindings, action.layoutIds, commit.decision.preservePreviousSlotIds)
+				slotBindings: mergeSlotBindings(state.slotBindings, action.slotBindings, action.layoutIds, preservePreviousSlotIds)
 			}, action.operation);
 		}
 		case "replace": return commitVisibleRouterState(state, {

package/dist/server/app-fallback-renderer.d.ts

@@ -52,7 +52,8 @@ type AppFallbackRendererOptions<TModule extends AppPageModule = AppPageModule> =
   loadGlobalNotFoundModule?: (() => Promise<TModule | null | undefined>) | null;
   makeThenableParams: (params: AppPageParams) => unknown;
   metadataRoutes: MetadataFileRoute[]; /** Configured next.config `basePath`, threaded into file-based metadata href emission. */
-  basePath?: string;
+  basePath?: string; /** Configured next.config `trailingSlash`, threaded into canonical URL rendering. */
+  trailingSlash?: boolean;
   resolveChildSegments: (routeSegments: readonly string[], treePosition: number, params: AppPageParams) => string[];
   rootBoundaries: AppFallbackRendererRootBoundaries<TModule>;
   rscRenderer: (element: ReactNode | AppElements, options: {

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

@@ -7,7 +7,7 @@ const EMPTY_MW_CTX = {
 	status: null
 };
 function createAppFallbackRenderer(options) {
-	const { basePath = "", clearRequestContext, createRscOnErrorHandler: buildRscOnErrorHandler, fontProviders, getNavigationContext, globalErrorModule, loadGlobalNotFoundModule, makeThenableParams, metadataRoutes, resolveChildSegments, rootBoundaries, rscRenderer, sanitizer, ssrLoader } = options;
+	const { basePath = "", clearRequestContext, createRscOnErrorHandler: buildRscOnErrorHandler, fontProviders, getNavigationContext, globalErrorModule, loadGlobalNotFoundModule, makeThenableParams, metadataRoutes, resolveChildSegments, rootBoundaries, rscRenderer, sanitizer, ssrLoader, trailingSlash } = options;
 	const { rootForbiddenModule, rootLayouts, rootNotFoundModule, rootUnauthorizedModule } = rootBoundaries;
 	const effectiveGlobalErrorModule = globalErrorModule ?? DEFAULT_GLOBAL_ERROR_MODULE;
 	const effectiveRootNotFoundModule = rootNotFoundModule ?? DEFAULT_NOT_FOUND_MODULE;
@@ -58,6 +58,7 @@ function createAppFallbackRenderer(options) {
 			}
 			return renderAppPageHttpAccessFallback({
 				basePath,
+				trailingSlash,
 				boundaryComponent: opts?.boundaryComponent ?? null,
 				boundaryModule: opts?.boundaryModule ?? null,
 				buildFontLinkHeader: fontProviders.buildFontLinkHeader,
@@ -96,6 +97,7 @@ function createAppFallbackRenderer(options) {
 		renderErrorBoundary(route, error, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext) {
 			return renderAppPageErrorBoundary({
 				basePath,
+				trailingSlash,
 				buildFontLinkHeader: fontProviders.buildFontLinkHeader,
 				clearRequestContext,
 				createRscOnErrorHandler(pathname, routePath) {

package/dist/server/app-history-state.d.ts

@@ -10,6 +10,50 @@ type HistoryTraversalIntent = {
   historyState: unknown;
   targetHistoryIndex: number | null;
 };
+type HistoryStateSnapshotRestoreDecision<TState> = {
+  kind: "restore";
+  state: TState;
+  targetHistoryIndex: number;
+} | {
+  kind: "skip";
+  reason: "guarded" | "missing-history-index" | "missing-snapshot" | "stale-bfcache-version";
+  targetHistoryIndex: number | null;
+};
+declare class HistoryStateSnapshotCache<TState> {
+  #private;
+  constructor(options: {
+    maxEntries: number;
+  });
+  clear(): void;
+  remember(options: {
+    bfcacheVersion: number;
+    historyIndex: number | null;
+    state: TState;
+  }): void;
+  resolveRestore(options: {
+    currentBfcacheVersion: number;
+    guarded: boolean;
+    historyState: unknown;
+  }): HistoryStateSnapshotRestoreDecision<TState>;
+}
+declare class RestorableClientStateController<TState> {
+  #private;
+  constructor(options: {
+    initialHistoryState: unknown;
+    maxHistoryStateSnapshots: number;
+  });
+  get currentBfcacheVersion(): number;
+  beginCacheInvalidationGuard(): () => void;
+  isCacheInvalidationGuarded(): boolean;
+  isCurrentBfcacheVersion(historyState: unknown): boolean;
+  readCurrentBfcacheVersionHistoryIds(historyState: unknown): BfcacheIdMap | null;
+  invalidateClientState(): void;
+  rememberHistoryStateSnapshot(options: {
+    historyIndex: number | null;
+    state: TState;
+  }): void;
+  resolveHistoryStateSnapshotRestore(historyState: unknown): HistoryStateSnapshotRestoreDecision<TState>;
+}
 declare function createHistoryStateWithPreviousNextUrl(state: unknown, previousNextUrl: string | null): HistoryStateRecord | null;
 declare function createHistoryStateWithNavigationMetadata(state: unknown, metadata: {
   bfcacheIds?: BfcacheIdMap | null;
@@ -39,4 +83,4 @@ declare function resolveHistoryTraversalIntent(options: {
   historyState: unknown;
 }): HistoryTraversalIntent;
 //#endregion
-export { BfcacheIdMap, HistoryTraversalIntent, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
+export { BfcacheIdMap, HistoryStateSnapshotCache, HistoryTraversalIntent, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

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

@@ -6,6 +6,114 @@ const VINEXT_PREVIOUS_NEXT_URL_HISTORY_STATE_KEY = "__vinext_previousNextUrl";
 const VINEXT_HISTORY_INDEX_HISTORY_STATE_KEY = "__vinext_historyIndex";
 const VINEXT_BFCACHE_IDS_HISTORY_STATE_KEY = "__vinext_bfcacheIds";
 const VINEXT_BFCACHE_VERSION_HISTORY_STATE_KEY = "__vinext_bfcacheVersion";
+var HistoryStateSnapshotCache = class {
+	#maxEntries;
+	#snapshots = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.#maxEntries = options.maxEntries;
+	}
+	clear() {
+		this.#snapshots.clear();
+	}
+	remember(options) {
+		if (options.historyIndex === null) return;
+		this.#snapshots.delete(options.historyIndex);
+		this.#snapshots.set(options.historyIndex, {
+			bfcacheVersion: options.bfcacheVersion,
+			state: options.state
+		});
+		if (this.#snapshots.size <= this.#maxEntries) return;
+		const oldestIndex = this.#snapshots.keys().next().value;
+		if (typeof oldestIndex === "number") this.#snapshots.delete(oldestIndex);
+	}
+	resolveRestore(options) {
+		const targetHistoryIndex = readHistoryStateTraversalIndex(options.historyState);
+		if (targetHistoryIndex === null) return {
+			kind: "skip",
+			reason: "missing-history-index",
+			targetHistoryIndex
+		};
+		const snapshot = this.#snapshots.get(targetHistoryIndex);
+		if (!snapshot) return {
+			kind: "skip",
+			reason: "missing-snapshot",
+			targetHistoryIndex
+		};
+		if (options.guarded) return {
+			kind: "skip",
+			reason: "guarded",
+			targetHistoryIndex
+		};
+		if (snapshot.bfcacheVersion !== options.currentBfcacheVersion) {
+			this.#snapshots.delete(targetHistoryIndex);
+			return {
+				kind: "skip",
+				reason: "stale-bfcache-version",
+				targetHistoryIndex
+			};
+		}
+		return {
+			kind: "restore",
+			state: snapshot.state,
+			targetHistoryIndex
+		};
+	}
+};
+var RestorableClientStateController = class {
+	#currentBfcacheVersion;
+	#pendingCacheInvalidationGuards = 0;
+	#snapshots;
+	constructor(options) {
+		const initialHistoryBfcacheVersion = readHistoryStateBfcacheVersion(options.initialHistoryState);
+		this.#currentBfcacheVersion = initialHistoryBfcacheVersion === null ? 0 : initialHistoryBfcacheVersion + 1;
+		this.#snapshots = new HistoryStateSnapshotCache({ maxEntries: options.maxHistoryStateSnapshots });
+	}
+	get currentBfcacheVersion() {
+		return this.#currentBfcacheVersion;
+	}
+	beginCacheInvalidationGuard() {
+		this.#pendingCacheInvalidationGuards += 1;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			this.#pendingCacheInvalidationGuards = Math.max(0, this.#pendingCacheInvalidationGuards - 1);
+		};
+	}
+	isCacheInvalidationGuarded() {
+		return this.#pendingCacheInvalidationGuards > 0;
+	}
+	isCurrentBfcacheVersion(historyState) {
+		return isHistoryStateBfcacheVersionCurrent(historyState, this.#currentBfcacheVersion);
+	}
+	readCurrentBfcacheVersionHistoryIds(historyState) {
+		if (this.isCacheInvalidationGuarded()) return null;
+		const ids = readHistoryStateBfcacheIds(historyState);
+		if (ids === null) return null;
+		return this.isCurrentBfcacheVersion(historyState) ? ids : null;
+	}
+	#invalidateBfcacheIds() {
+		this.#currentBfcacheVersion += 1;
+	}
+	invalidateClientState() {
+		this.#snapshots.clear();
+		this.#invalidateBfcacheIds();
+	}
+	rememberHistoryStateSnapshot(options) {
+		this.#snapshots.remember({
+			bfcacheVersion: this.#currentBfcacheVersion,
+			historyIndex: options.historyIndex,
+			state: options.state
+		});
+	}
+	resolveHistoryStateSnapshotRestore(historyState) {
+		return this.#snapshots.resolveRestore({
+			currentBfcacheVersion: this.#currentBfcacheVersion,
+			guarded: this.isCacheInvalidationGuarded(),
+			historyState
+		});
+	}
+};
 function cloneHistoryState(state) {
 	if (!state || typeof state !== "object") return {};
 	const nextState = {};
@@ -112,4 +220,4 @@ function resolveHistoryTraversalIntent(options) {
 	};
 }
 //#endregion
-export { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
+export { HistoryStateSnapshotCache, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

package/dist/server/app-middleware.js

@@ -115,6 +115,7 @@ async function applyAppMiddleware(options) {
 	if (!forwarded.applied) {
 		const result = await executeMiddleware({
 			basePath: options.basePath,
+			hadBasePath: true,
 			i18nConfig: options.i18nConfig,
 			isDataRequest: options.isDataRequest,
 			isProxy: options.isProxy,

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

@@ -1,5 +1,6 @@
 import { buildParams, decodeMatchedParams, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
@@ -135,6 +136,20 @@ function matchOptimisticRouteManifestRoute(options) {
 	decodeMatchedParams(match.params);
 	return match;
 }
+function mergeParams(target, source) {
+	for (const [key, value] of Object.entries(source)) target[key] = value;
+}
+function resolveOptimisticNavigationParams(options) {
+	const navigationParams = { ...options.match.params };
+	for (const binding of options.routeManifest.segmentGraph.slotBindings.values()) {
+		if (binding.routeId !== options.match.route.id || binding.state !== "active") continue;
+		const patternParts = binding.slotPatternParts;
+		if (!patternParts) continue;
+		const matched = matchRoutePattern(options.urlParts, patternParts);
+		if (matched) mergeParams(navigationParams, matched);
+	}
+	return navigationParams;
+}
 function elementHasSuspenseFallback(value, depth = 0) {
 	if (depth > 100) return false;
 	if (Array.isArray(value)) return value.some((entry) => elementHasSuspenseFallback(entry, depth + 1));
@@ -183,6 +198,8 @@ function createOptimisticRouteElements(template) {
 }
 function resolveOptimisticNavigationPayload(options) {
 	if (options.interceptionContext !== null) return null;
+	const urlParts = hrefToRouteParts(options.href, options.basePath);
+	if (urlParts === null) return null;
 	const match = matchOptimisticRouteManifestRoute({
 		basePath: options.basePath,
 		href: options.href,
@@ -198,7 +215,11 @@ function resolveOptimisticNavigationPayload(options) {
 	if (template.mountedSlotsHeader !== options.mountedSlotsHeader) return null;
 	return {
 		elements: createOptimisticRouteElements(template),
-		params: match.params,
+		params: resolveOptimisticNavigationParams({
+			match,
+			routeManifest: options.routeManifest,
+			urlParts
+		}),
 		template
 	};
 }

package/dist/server/app-page-boundary-render.d.ts

@@ -41,7 +41,8 @@ type AppPageBoundaryRenderCommonOptions<TModule extends AppPageModule = AppPageM
   makeThenableParams: (params: AppPageParams) => unknown;
   middlewareContext: AppPageMiddlewareContext;
   metadataRoutes: MetadataFileRoute[]; /** Configured next.config `basePath`, threaded into file-based metadata href emission. */
-  basePath?: string;
+  basePath?: string; /** Configured next.config `trailingSlash`, threaded into canonical URL rendering. */
+  trailingSlash?: boolean;
   renderToReadableStream: (element: ReactNode | AppElements, options: {
     onError: AppPageBoundaryOnError;
   }) => ReadableStream<Uint8Array>;

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

@@ -1,15 +1,19 @@
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { ErrorBoundary } from "../shims/error-boundary.js";
+import { isNavigationSignalError } from "../utils/navigation-signal.js";
+import { ErrorBoundary, GlobalErrorBoundary } from "../shims/error-boundary.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead } from "../shims/metadata.js";
+import { resolveAppPageSpecialError } from "./app-page-execution.js";
 import { resolveAppPageHead } from "./app-page-head.js";
 import { createAppPageLayoutEntries } from "./app-page-route-wiring.js";
 import { buildClientHookErrorMessage } from "../shims/client-hook-error.js";
+import DefaultGlobalError from "../shims/default-global-error.js";
 import { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryModule, wrapAppPageBoundaryElement } from "./app-page-boundary.js";
 import { createAppPageFontData, renderAppPageHtmlResponse } from "./app-page-stream.js";
 import { Fragment, createElement } from "react";
 //#region src/server/app-page-boundary-render.ts
+const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
 function getDefaultExport(module) {
 	return module?.default ?? null;
 }
@@ -25,9 +29,12 @@ function wrapRenderedBoundaryElement(options) {
 		makeThenableParams: options.makeThenableParams,
 		matchedParams: options.matchedParams,
 		renderErrorBoundary(GlobalErrorComponent, children) {
-			return createElement(ErrorBoundary, {
-				fallback: GlobalErrorComponent,
-				children
+			return createElement(GlobalErrorBoundary, {
+				fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+				children: createElement(ErrorBoundary, {
+					fallback: GlobalErrorComponent,
+					children
+				})
 			});
 		},
 		renderLayout(LayoutComponent, children, asyncParams) {
@@ -161,7 +168,8 @@ async function renderAppPageHttpAccessFallback(options) {
 	if (metadata) headElements.push(createElement(MetadataHead, {
 		key: "metadata",
 		metadata,
-		pathname
+		pathname,
+		trailingSlash: options.trailingSlash
 	}));
 	headElements.push(createElement(ViewportHead, {
 		key: "viewport",
@@ -224,7 +232,8 @@ async function renderAppPageErrorBoundary(options) {
 		if (metadata) headElements.push(createElement(MetadataHead, {
 			key: "metadata",
 			metadata,
-			pathname
+			pathname,
+			trailingSlash: options.trailingSlash
 		}));
 		headElements.push(createElement(ViewportHead, {
 			key: "viewport",
@@ -233,22 +242,28 @@ async function renderAppPageErrorBoundary(options) {
 	} catch (error) {
 		console.error(`[vinext] App page error boundary head resolution failed for ${options.route?.pattern ?? pathname}:`, error);
 	}
-	const element = wrapRenderedBoundaryElement({
-		element: createElement(Fragment, null, ...headElements, createElement(errorBoundary.component, { error: errorObject })),
-		globalErrorModule: options.globalErrorModule,
-		includeGlobalErrorBoundary: !errorBoundary.isGlobalError,
-		isRscRequest: options.isRscRequest,
-		layoutModules,
-		layoutTreePositions: options.route?.layoutTreePositions,
-		makeThenableParams: options.makeThenableParams,
-		matchedParams,
-		resolveChildSegments: options.resolveChildSegments,
-		routeSegments: options.route?.routeSegments,
-		skipLayoutWrapping: errorBoundary.isGlobalError
-	});
-	return renderAppPageBoundaryElementResponse({
+	const buildElement = (BoundaryComponent) => {
+		const boundaryElement = createElement(BoundaryComponent, { error: errorObject });
+		return wrapRenderedBoundaryElement({
+			element: createElement(Fragment, null, ...headElements, errorBoundary.isGlobalError ? createElement(GlobalErrorBoundary, {
+				fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+				children: boundaryElement
+			}) : boundaryElement),
+			globalErrorModule: options.globalErrorModule,
+			includeGlobalErrorBoundary: !errorBoundary.isGlobalError,
+			isRscRequest: options.isRscRequest,
+			layoutModules,
+			layoutTreePositions: options.route?.layoutTreePositions,
+			makeThenableParams: options.makeThenableParams,
+			matchedParams,
+			resolveChildSegments: options.resolveChildSegments,
+			routeSegments: options.route?.routeSegments,
+			skipLayoutWrapping: errorBoundary.isGlobalError
+		});
+	};
+	const renderWith = (BoundaryComponent) => renderAppPageBoundaryElementResponse({
 		...options,
-		element,
+		element: buildElement(BoundaryComponent),
 		initialDevServerError: rawError,
 		layoutModules,
 		navigationParams: matchedParams,
@@ -256,6 +271,15 @@ async function renderAppPageErrorBoundary(options) {
 		routePattern: options.route?.pattern,
 		status: 200
 	});
+	try {
+		return await renderWith(errorBoundary.component);
+	} catch (renderError) {
+		if (errorBoundary.isGlobalError && !isNavigationSignalError(renderError) && !resolveAppPageSpecialError(renderError)) {
+			console.error(`[vinext] global-error.tsx threw while rendering for ${options.route?.pattern ?? pathname}; falling back to the built-in default global-error:`, renderError);
+			return renderWith(DEFAULT_GLOBAL_ERROR_COMPONENT);
+		}
+		throw renderError;
+	}
 }
 const _clientHookPattern = /\b(useState|useEffect|useReducer|useRef|useContext|useLayoutEffect|useInsertionEffect|useSyncExternalStore|useTransition|useImperativeHandle|useDeferredValue|useActionState|useOptimistic|useEffectEvent)\b.*is not a function/;
 function rewriteClientHookError(error) {