vinext 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/routing/app-route-graph.d.ts

@@ -1,9 +1,12 @@
 import { ValidFileMatcher } from "./file-matcher.js";
 import { isInvisibleSegment } from "./utils.js";
-
 //#region src/routing/app-route-graph.d.ts
 type InterceptingRoute = {
-  /** The interception convention: "." | ".." | "../.." | "..." */convention: string; /** The URL pattern this intercepts (e.g. "/photos/:id") */
+  /** Graph-owned identity for this interception edge. */
+  id?: string;
+  /** The interception convention: "." | ".." | "../.." | "..." */
+  convention: string;
+  /** The URL pattern this intercepts (e.g. "/photos/:id") */
   targetPattern: string;
   /**
    * URL pattern of the *intercepting route* — the path that owns the slot
@@ -20,17 +23,28 @@ type InterceptingRoute = {
    * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/lib/generate-interception-routes-rewrites.ts
    * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/interception-routes.ts
    */
-  sourceMatchPattern: string; /** Absolute path to the intercepting page component */
-  pagePath: string; /** Filesystem segments from app/ root to the intercepting page directory. */
-  sourcePageSegments?: string[]; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
-  layoutPaths: string[]; /** Normalized branch segments accumulated at each intercept layout. */
-  layoutSegments?: string[][]; /** Loading conventions inside the intercepted branch, outermost to innermost. */
-  loadingPaths?: string[]; /** Tree positions for loadingPaths in the normalized interception branch. */
-  loadingTreePositions?: number[]; /** Full normalized interception branch segments through the page. */
-  branchSegments?: string[]; /** Nearest not-found convention inside the interception branch. */
-  notFoundPath?: string | null; /** Slot-root-relative branch segments used to scope not-found params. */
-  notFoundBranchSegments?: string[]; /** Tree position relative to the normalized interception branch. */
-  notFoundTreePosition?: number | null; /** Parameter names for dynamic segments */
+  sourceMatchPattern: string;
+  /** Absolute path to the intercepting page component */
+  pagePath: string;
+  /** Filesystem segments from app/ root to the intercepting page directory. */
+  sourcePageSegments?: string[];
+  /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
+  layoutPaths: string[];
+  /** Normalized branch segments accumulated at each intercept layout. */
+  layoutSegments?: string[][];
+  /** Loading conventions inside the intercepted branch, outermost to innermost. */
+  loadingPaths?: string[];
+  /** Tree positions for loadingPaths in the normalized interception branch. */
+  loadingTreePositions?: number[];
+  /** Full normalized interception branch segments through the page. */
+  branchSegments?: string[];
+  /** Nearest not-found convention inside the interception branch. */
+  notFoundPath?: string | null;
+  /** Slot-root-relative branch segments used to scope not-found params. */
+  notFoundBranchSegments?: string[];
+  /** Tree position relative to the normalized interception branch. */
+  notFoundTreePosition?: number | null;
+  /** Parameter names for dynamic segments */
   params: string[];
   /**
    * Synthetic page-carrier slot id for sibling (slot-less) interception.
@@ -39,24 +53,43 @@ type InterceptingRoute = {
   slotId?: string;
 };
 type ParallelSlot = {
-  /** Graph-owned semantic slot identity. Required on AppRouteGraphParallelSlot. */id?: string; /** Stable slot identity (name + owning directory), used for route serialization keys. */
-  key: string; /** Slot name (e.g. "team" from @team) */
-  name: string; /** Absolute path to the @slot directory that owns this slot. Internal routing metadata. */
-  ownerDir: string; /** Stable tree path for the directory whose layout owns this slot. */
-  ownerTreePath: string; /** Directory depth of the slot owner from app/ root. */
-  ownerTreePosition?: number; /** Whether the slot owner directory declares its own page component. */
-  hasPage: boolean; /** Absolute path to the slot's page component */
-  pagePath: string | null; /** Absolute path to the slot's default.tsx fallback */
-  defaultPath: string | null; /** Absolute path to the slot's layout component (wraps slot content) */
-  layoutPath: string | null; /** Nested active-branch layouts whose exports contribute route config. */
-  configLayoutPaths?: string[]; /** Tree positions of configLayoutPaths relative to the slot root. */
-  configLayoutTreePositions?: number[]; /** Absolute path to the slot's loading component */
-  loadingPath: string | null; /** Per-segment loading components from the slot root to its active page. */
-  loadingPaths?: string[]; /** Slot-root-relative tree positions aligned with loadingPaths. */
-  loadingTreePositions?: number[]; /** Absolute path to the slot's error component */
-  errorPath: string | null; /** Nearest not-found convention for the slot's active branch. */
-  notFoundPath?: string | null; /** Tree position of that convention relative to the slot root. */
-  notFoundTreePosition?: number | null; /** Intercepting routes within this slot */
+  /** Graph-owned semantic slot identity. Required on AppRouteGraphParallelSlot. */
+  id?: string;
+  /** Stable slot identity (name + owning directory), used for route serialization keys. */
+  key: string;
+  /** Slot name (e.g. "team" from @team) */
+  name: string;
+  /** Absolute path to the @slot directory that owns this slot. Internal routing metadata. */
+  ownerDir: string;
+  /** Stable tree path for the directory whose layout owns this slot. */
+  ownerTreePath: string;
+  /** Directory depth of the slot owner from app/ root. */
+  ownerTreePosition?: number;
+  /** Whether the slot owner directory declares its own page component. */
+  hasPage: boolean;
+  /** Absolute path to the slot's page component */
+  pagePath: string | null;
+  /** Absolute path to the slot's default.tsx fallback */
+  defaultPath: string | null;
+  /** Absolute path to the slot's layout component (wraps slot content) */
+  layoutPath: string | null;
+  /** Nested active-branch layouts whose exports contribute route config. */
+  configLayoutPaths?: string[];
+  /** Tree positions of configLayoutPaths relative to the slot root. */
+  configLayoutTreePositions?: number[];
+  /** Absolute path to the slot's loading component */
+  loadingPath: string | null;
+  /** Per-segment loading components from the slot root to its active page. */
+  loadingPaths?: string[];
+  /** Slot-root-relative tree positions aligned with loadingPaths. */
+  loadingTreePositions?: number[];
+  /** Absolute path to the slot's error component */
+  errorPath: string | null;
+  /** Nearest not-found convention for the slot's active branch. */
+  notFoundPath?: string | null;
+  /** Tree position of that convention relative to the slot root. */
+  notFoundTreePosition?: number | null;
+  /** Intercepting routes within this slot */
   interceptingRoutes: InterceptingRoute[];
   /**
    * The layout index (0-based, in route.layouts[]) that this slot belongs to.
@@ -87,13 +120,21 @@ type ParallelSlot = {
   slotParamNames?: string[];
 };
 type AppRoute = {
-  /** Graph-owned semantic identities. Required on AppRouteGraphRoute. */ids?: AppRouteSemanticIds; /** URL pattern, e.g. "/" or "/about" or "/blog/:slug" */
-  pattern: string; /** Absolute file path to the page component */
-  pagePath: string | null; /** Absolute file path to the route handler (route.ts) */
-  routePath: string | null; /** Ordered list of layout files from root to leaf */
-  layouts: string[]; /** Ordered list of all discovered template files from root to leaf (not necessarily aligned 1:1 with layouts) */
-  templates: string[]; /** Parallel route slots (from @slot directories at the route's directory level) */
-  parallelSlots: ParallelSlot[]; /** Stable implicit children-slot identity for parallel-slot sub-route families. */
+  /** Graph-owned semantic identities. Required on AppRouteGraphRoute. */
+  ids?: AppRouteSemanticIds;
+  /** URL pattern, e.g. "/" or "/about" or "/blog/:slug" */
+  pattern: string;
+  /** Absolute file path to the page component */
+  pagePath: string | null;
+  /** Absolute file path to the route handler (route.ts) */
+  routePath: string | null;
+  /** Ordered list of layout files from root to leaf */
+  layouts: string[];
+  /** Ordered list of all discovered template files from root to leaf (not necessarily aligned 1:1 with layouts) */
+  templates: string[];
+  /** Parallel route slots (from @slot directories at the route's directory level) */
+  parallelSlots: ParallelSlot[];
+  /** Stable implicit children-slot identity for parallel-slot sub-route families. */
   childrenSlot?: {
     id: string;
     ownerTreePath: string;
@@ -104,20 +145,28 @@ type AppRoute = {
    * On soft-nav, the intercepting page replaces the entire page response.
    * Empty array when there are no sibling-style interception markers.
    */
-  siblingIntercepts: InterceptingRoute[]; /** Loading component path (leaf directory only) */
-  loadingPath: string | null; /** Per-segment loading component paths, aligned with loadingTreePositions. */
-  loadingPaths?: string[]; /** Tree position (directory depth from app/ root) for each loading boundary. */
-  loadingTreePositions?: number[]; /** Error component path (leaf directory only) */
+  siblingIntercepts: InterceptingRoute[];
+  /** Loading component path (leaf directory only) */
+  loadingPath: string | null;
+  /** Per-segment loading component paths, aligned with loadingTreePositions. */
+  loadingPaths?: string[];
+  /** Tree position (directory depth from app/ root) for each loading boundary. */
+  loadingTreePositions?: number[];
+  /** Error component path (leaf directory only) */
   errorPath: string | null;
   /**
    * Per-layout error boundary paths, aligned with the layouts array.
    * Each entry is the error.tsx at the same directory level as the
    * corresponding layout (or null if that level has no error.tsx).
    */
-  layoutErrorPaths: (string | null)[]; /** Per-segment error boundary paths, aligned with errorTreePositions. */
-  errorPaths?: string[]; /** Tree position (directory depth from app/ root) for each error boundary. */
-  errorTreePositions?: number[]; /** Not-found component path (nearest, walking up from page dir) */
-  notFoundPath: string | null; /** Tree position of the nearest not-found component's owning segment. */
+  layoutErrorPaths: (string | null)[];
+  /** Per-segment error boundary paths, aligned with errorTreePositions. */
+  errorPaths?: string[];
+  /** Tree position (directory depth from app/ root) for each error boundary. */
+  errorTreePositions?: number[];
+  /** Not-found component path (nearest, walking up from page dir) */
+  notFoundPath: string | null;
+  /** Tree position of the nearest not-found component's owning segment. */
   notFoundTreePosition?: number | null;
   /**
    * Not-found component paths per layout level (aligned with layouts array).
@@ -131,11 +180,16 @@ type AppRoute = {
    * Each entry is the forbidden.tsx at that layout's directory, or null.
    * Used to create per-layout ForbiddenBoundary.
    */
-  forbiddenPaths: (string | null)[]; /** Forbidden component path (403) at the route's directory level */
-  forbiddenPath: string | null; /** Tree position of the nearest forbidden component's owning segment. */
-  forbiddenTreePosition?: number | null; /** Unauthorized component path (401) at the route's directory level */
-  unauthorizedPath: string | null; /** Tree position of the nearest unauthorized component's owning segment. */
-  unauthorizedTreePosition?: number | null; /** Unauthorized component paths per layout level (aligned with layouts array). */
+  forbiddenPaths: (string | null)[];
+  /** Forbidden component path (403) at the route's directory level */
+  forbiddenPath: string | null;
+  /** Tree position of the nearest forbidden component's owning segment. */
+  forbiddenTreePosition?: number | null;
+  /** Unauthorized component path (401) at the route's directory level */
+  unauthorizedPath: string | null;
+  /** Tree position of the nearest unauthorized component's owning segment. */
+  unauthorizedTreePosition?: number | null;
+  /** Unauthorized component paths per layout level (aligned with layouts array). */
   unauthorizedPaths: (string | null)[];
   /**
    * Filesystem segments from app/ root to the route's directory.
@@ -151,7 +205,8 @@ type AppRoute = {
    * but their children slot renders the parent's default.tsx. In that case the
    * active children segments remain at the parent route.
    */
-  childrenRouteSegments?: string[]; /** Tree position (directory depth from app/ root) for each template. */
+  childrenRouteSegments?: string[];
+  /** Tree position (directory depth from app/ root) for each template. */
   templateTreePositions?: number[];
   /**
    * Tree position (directory depth from app/ root) for each layout.
@@ -160,10 +215,14 @@ type AppRoute = {
    * Unlike the old layoutSegmentDepths, this counts ALL directory levels including
    * route groups and parallel slots.
    */
-  layoutTreePositions: number[]; /** Whether this is a dynamic route */
-  isDynamic: boolean; /** Parameter names for dynamic segments */
-  params: string[]; /** Dynamic parameter names captured by the route's root layout. */
-  rootParamNames?: string[]; /** Pre-split pattern segments (computed once at scan time, reused per request) */
+  layoutTreePositions: number[];
+  /** Whether this is a dynamic route */
+  isDynamic: boolean;
+  /** Parameter names for dynamic segments */
+  params: string[];
+  /** Dynamic parameter names captured by the route's root layout. */
+  rootParamNames?: string[];
+  /** Pre-split pattern segments (computed once at scan time, reused per request) */
   patternParts: string[];
 };
 type AppRouteSemanticIds = {

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

@@ -201,7 +201,7 @@ function createStaticSegmentGraph(routes) {
 		}
 		for (const ir of route.siblingIntercepts) {
 			if (!ir.slotId) continue;
-			const id = createAppRouteGraphInterceptionId(ir.slotId, ir.sourceMatchPattern, ir.targetPattern);
+			const id = ir.id ?? createAppRouteGraphInterceptionId(ir.slotId, ir.sourceMatchPattern, ir.targetPattern);
 			interceptions.set(id, {
 				id,
 				sourcePattern: ir.sourceMatchPattern,
@@ -1386,6 +1386,7 @@ function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 				collectInterceptingPages(childDir, childDir, marker.convention, restOfName, parentDir, appDir, parentDir, null, results, matcher);
 				for (const ir of results) {
 					ir.slotId = createAppRouteGraphSiblingInterceptSlotId(ir.sourceMatchPattern);
+					ir.id = createAppRouteGraphInterceptionId(ir.slotId, ir.sourceMatchPattern, ir.targetPattern);
 					const owner = findOwnerRouteForDir(parentDir, appDir, routes, routesByDir);
 					if (owner) owner.siblingIntercepts.push(ir);
 				}

package/dist/routing/app-router.d.ts

@@ -1,6 +1,5 @@
 import { ValidFileMatcher } from "./file-matcher.js";
 import { AppRoute, AppRouteGraphRoute, RouteManifest, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts } from "./app-route-graph.js";
-
 //#region src/routing/app-router.d.ts
 type AppRouteGraph = {
   routes: AppRouteGraphRoute[];

package/dist/routing/pages-router.d.ts

@@ -1,12 +1,16 @@
 import { ValidFileMatcher } from "./file-matcher.js";
 import { patternToNextFormat } from "./route-validation.js";
-
 //#region src/routing/pages-router.d.ts
 type Route = {
-  /** URL pattern, e.g. "/" or "/about" or "/posts/:id" */pattern: string; /** Pre-split pattern segments (computed once at scan time, reused per request) */
-  patternParts: string[]; /** Absolute file path to the page component */
-  filePath: string; /** Whether this is a dynamic route */
-  isDynamic: boolean; /** Parameter names for dynamic segments */
+  /** URL pattern, e.g. "/" or "/about" or "/posts/:id" */
+  pattern: string;
+  /** Pre-split pattern segments (computed once at scan time, reused per request) */
+  patternParts: string[];
+  /** Absolute file path to the page component */
+  filePath: string;
+  /** Whether this is a dynamic route */
+  isDynamic: boolean;
+  /** Parameter names for dynamic segments */
   params: string[];
 };
 /**

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

@@ -1,5 +1,4 @@
 import { TrieNode } from "./route-trie.js";
-
 //#region src/routing/route-matching.d.ts
 type RouteTrieCache<R extends {
   patternParts: string[];

package/dist/routing/utils.d.ts

@@ -91,27 +91,5 @@ declare function isCatchAllSegment(segment: string): boolean;
  * this matches zero or more URL segments.
  */
 declare function isOptionalCatchAllSegment(segment: string): boolean;
-/**
- * Count how many pathname segments a tree path's *visible* segments consume,
- * given the total number of pathname segments available.
- *
- * This is the minimal pure slice of the canonical filesystem-segment →
- * URL-segment mapping in `app-route-graph.ts` (`convertSegmentsToRouteParts`),
- * extracted here so browser-side bfcache identity logic can share it without
- * importing the Node-bound route graph module. `convertSegmentsToRouteParts`
- * remains the source of truth for how each segment kind maps to a URL part.
- *
- * Each ordinary visible segment (static or `[x]`) consumes exactly one pathname
- * segment. A catch-all (`[...x]`) is terminal and consumes every remaining
- * pathname segment. An optional-catch-all (`[[...x]]`) is also terminal but may
- * match zero segments, so it consumes only the remaining pathname segments
- * (which is zero once preceding segments have already consumed the pathname) —
- * never more than are actually present.
- *
- * @param visibleTreePathSegments URL-visible tree-path segments (callers must
- *   pre-filter invisible segments via `isInvisibleSegment`).
- * @param pathnameSegmentCount Total number of pathname segments available.
- */
-declare function countConsumedPathnameSegments(visibleTreePathSegments: readonly string[], pathnameSegmentCount: number): number;
 //#endregion
-export { buildParams, compareHybridRoutePatterns, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, sortRoutes, splitPathSegments, splitPathnameForRouteMatch };
+export { buildParams, compareHybridRoutePatterns, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, sortRoutes, splitPathSegments, splitPathnameForRouteMatch };

package/dist/routing/utils.js

@@ -209,34 +209,5 @@ function isCatchAllSegment(segment) {
 function isOptionalCatchAllSegment(segment) {
 	return segment.startsWith("[[...") && segment.endsWith("]]") && segment.length > 7;
 }
-/**
-* Count how many pathname segments a tree path's *visible* segments consume,
-* given the total number of pathname segments available.
-*
-* This is the minimal pure slice of the canonical filesystem-segment →
-* URL-segment mapping in `app-route-graph.ts` (`convertSegmentsToRouteParts`),
-* extracted here so browser-side bfcache identity logic can share it without
-* importing the Node-bound route graph module. `convertSegmentsToRouteParts`
-* remains the source of truth for how each segment kind maps to a URL part.
-*
-* Each ordinary visible segment (static or `[x]`) consumes exactly one pathname
-* segment. A catch-all (`[...x]`) is terminal and consumes every remaining
-* pathname segment. An optional-catch-all (`[[...x]]`) is also terminal but may
-* match zero segments, so it consumes only the remaining pathname segments
-* (which is zero once preceding segments have already consumed the pathname) —
-* never more than are actually present.
-*
-* @param visibleTreePathSegments URL-visible tree-path segments (callers must
-*   pre-filter invisible segments via `isInvisibleSegment`).
-* @param pathnameSegmentCount Total number of pathname segments available.
-*/
-function countConsumedPathnameSegments(visibleTreePathSegments, pathnameSegmentCount) {
-	let consumed = 0;
-	for (const segment of visibleTreePathSegments) {
-		if (isCatchAllSegment(segment) || isOptionalCatchAllSegment(segment)) return Math.max(consumed, pathnameSegmentCount);
-		consumed += 1;
-	}
-	return consumed;
-}
 //#endregion
-export { buildParams, compareHybridRoutePatterns, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, sortRoutes, splitPathSegments, splitPathnameForRouteMatch };
+export { buildParams, compareHybridRoutePatterns, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, sortRoutes, splitPathSegments, splitPathnameForRouteMatch };

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

@@ -1,5 +1,4 @@
 import { IncomingMessage } from "node:http";
-
 //#region src/server/accept-encoding.d.ts
 type ContentEncoding = "zstd" | "br" | "gzip" | "deflate";
 type NegotiatedEncoding = ContentEncoding | "identity";

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

@@ -2,7 +2,6 @@ import { NextI18nConfig } from "../config/next-config.js";
 import { Route } from "../routing/pages-router.js";
 import { ModuleImporter } from "./instrumentation.js";
 import { IncomingMessage, ServerResponse } from "node:http";
-
 //#region src/server/api-handler.d.ts
 /**
  * Handle an API route request.

package/dist/server/api-handler.js

@@ -9,7 +9,7 @@ import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-medi
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { attachPagesPreviewApi, attachPagesRequestCookies } from "./pages-node-compat.js";
-import { isEdgeApiRuntime } from "./edge-api-runtime.js";
+import { finalizeEdgeApiResponse, isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { decode } from "node:querystring";
 import { Buffer } from "node:buffer";
 //#region src/server/api-handler.ts
@@ -227,8 +227,9 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 				i18n: nextConfig.i18n ?? void 0,
 				trailingSlash: nextConfig.trailingSlash
 			} } : void 0);
-			const response = await apiModule.default(nextRequest);
-			if (!(response instanceof Response)) throw new Error("Edge API route did not return a Response");
+			const handlerResponse = await apiModule.default(nextRequest);
+			if (!(handlerResponse instanceof Response)) throw new Error("Edge API route did not return a Response");
+			const response = finalizeEdgeApiResponse(handlerResponse, "node");
 			res.statusCode = response.status;
 			res.statusMessage = response.statusText;
 			const setCookieHeaders = response.headers.getSetCookie();

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

@@ -1,29 +1,26 @@
+import { BfcacheSegmentIdentity } from "./bfcache-identity.js";
 import { AppElements, AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
 import { BfcacheIdMap } from "./app-history-state.js";
-
 //#region src/server/app-bfcache-identity.d.ts
-type BfcacheStateKeyMap = Readonly<Record<string, string>>;
+type BfcacheSegmentIdentityMap = Readonly<Record<string, BfcacheSegmentIdentity>>;
 type InitialBfcacheMaps = Readonly<{
   bfcacheIds: BfcacheIdMap;
-  stateKeys: BfcacheStateKeyMap;
+  identities: BfcacheSegmentIdentityMap;
 }>;
 type AppElementsMetadata = ReturnType<typeof AppElementsWire.readMetadata>;
 declare function createInitialBfcacheIdMap(elements: AppElements): BfcacheIdMap;
-declare function createBfcacheSegmentStateKeyMap(options: {
+declare function createBfcacheSegmentIdentityMap(options: {
   elements: AppElements;
-  pathname: string;
-}): BfcacheStateKeyMap;
+}): BfcacheSegmentIdentityMap;
 declare function createInitialBfcacheMaps(options: {
   elements: AppElements;
   metadata: AppElementsMetadata;
-  pathname: string;
 }): InitialBfcacheMaps;
 declare function createNextBfcacheIdMap(options: {
   current: BfcacheIdMap;
   currentElements: AppElements;
-  currentPathname: string;
   elements: AppElements;
-  nextPathname: string;
   restored?: BfcacheIdMap | null;
   reuseCurrent?: boolean;
 }): BfcacheIdMap;
@@ -31,6 +28,8 @@ declare function preserveBfcacheIdsForMergedElements(options: {
   elements: AppElements;
   next: BfcacheIdMap;
   previous: BfcacheIdMap;
+  preservedElementIds?: readonly string[];
+  preservePreviousIds?: readonly string[];
 }): BfcacheIdMap;
 //#endregion
-export { BfcacheStateKeyMap, InitialBfcacheMaps, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };
+export { BfcacheSegmentIdentityMap, InitialBfcacheMaps, createBfcacheSegmentIdentityMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };

package/dist/server/app-bfcache-identity.js

@@ -1,8 +1,8 @@
-import { countConsumedPathnameSegments, isInvisibleSegment, normalizePathnameForRouteMatch, splitPathSegments } from "../routing/utils.js";
-import { normalizePath } from "./normalize-path.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { isNestedBfcacheSlotSegmentIdFor } from "./bfcache-identity.js";
 import "./app-bfcache-id.js";
+import { isBfcacheSegmentId } from "./app-history-state.js";
 //#region src/server/app-bfcache-identity.ts
 let nextBfcacheId = 0;
 function rememberBfcacheId(value) {
@@ -14,106 +14,35 @@ function mintBfcacheId() {
 	nextBfcacheId += 1;
 	return `_b_${nextBfcacheId}_`;
 }
-function getVisibleTreePathSegments(treePath) {
-	return splitPathSegments(treePath).filter((segment) => !isInvisibleSegment(segment));
-}
-function getTreePathIdentityPrefix(pathname, treePath) {
-	const pathnameSegments = splitPathSegments(pathname);
-	const consumedPathnameSegments = countConsumedPathnameSegments(getVisibleTreePathSegments(treePath), pathnameSegments.length);
-	if (consumedPathnameSegments === 0) return "/";
-	return `/${pathnameSegments.slice(0, consumedPathnameSegments).join("/")}`;
-}
-function indexAppElementsMetadata(metadata) {
-	const slotBindingsBySlotId = /* @__PURE__ */ new Map();
-	for (const binding of metadata.slotBindings) slotBindingsBySlotId.set(binding.slotId, binding);
-	return {
-		metadata,
-		slotBindingsBySlotId
-	};
-}
 function readAppElementsMetadata(elements) {
-	let metadata;
 	try {
-		metadata = AppElementsWire.readMetadata(elements);
+		return AppElementsWire.readMetadata(elements);
 	} catch {
 		return null;
 	}
-	return indexAppElementsMetadata(metadata);
-}
-function parseBfcacheSegmentKey(id) {
-	const parsed = AppElementsWire.parseElementKey(id);
-	return parsed !== null && parsed.kind !== "route" ? parsed : null;
-}
-function createActiveSlotIdentity(id, parsed) {
-	const activeSlotBinding = parsed?.slotBindingsBySlotId.get(id);
-	if (activeSlotBinding?.activeRouteId != null) return `${id}@${activeSlotBinding.activeRouteId}`;
-	const interception = parsed?.metadata.interception;
-	if (interception?.slotId !== id) return null;
-	return `${id}@${interception.targetRouteId}`;
 }
-/**
-* Derive BFCache identity from AppElements wire keys. Keep wire-key parsing
-* contained here until vinext has a route-manifest authority equivalent to
-* Next.js CacheNode or segment-cache state.
-*/
-function createBfcacheSegmentIdentity(id, parsed, options) {
-	if (parsed.kind === "page") return `${id}@${options.pathname}`;
-	if (parsed.kind === "slot") {
-		const activeSlotIdentity = createActiveSlotIdentity(id, options.metadata);
-		if (activeSlotIdentity !== null) return activeSlotIdentity;
-		return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
-	}
-	if (parsed.kind === "layout" || parsed.kind === "template") return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
-	return null;
-}
-function collectBfcacheSegmentIdCandidates(elements, metadata = readAppElementsMetadata(elements)) {
+function collectBfcacheSegmentIds(elements, metadata) {
 	const ids = new Set(Object.keys(elements));
-	for (const layoutId of metadata?.metadata.layoutIds ?? []) ids.add(layoutId);
-	return ids;
+	const parsedMetadata = metadata === void 0 ? readAppElementsMetadata(elements) : metadata;
+	for (const layoutId of parsedMetadata?.layoutIds ?? []) ids.add(layoutId);
+	for (const identityId of Object.keys(parsedMetadata?.bfcacheSegmentIdentities ?? {})) ids.add(identityId);
+	return Array.from(ids).filter(isBfcacheSegmentId);
 }
 function createInitialBfcacheIdMap(elements) {
 	const bfcacheIds = {};
-	for (const id of collectBfcacheSegmentIdCandidates(elements)) if (parseBfcacheSegmentKey(id) !== null) bfcacheIds[id] = "0";
+	for (const id of collectBfcacheSegmentIds(elements)) bfcacheIds[id] = "0";
 	return bfcacheIds;
 }
-function normalizeBfcachePathname(pathname) {
-	const normalized = normalizePath(normalizePathnameForRouteMatch(pathname));
-	return normalized.length > 1 ? normalized.replace(/\/$/, "") : normalized;
-}
-function createBfcacheSegmentStateKeyMap(options) {
-	const metadata = readAppElementsMetadata(options.elements);
-	const normalizedPathname = normalizeBfcachePathname(options.pathname);
-	const stateKeys = {};
-	for (const id of collectBfcacheSegmentIdCandidates(options.elements, metadata)) {
-		const parsed = parseBfcacheSegmentKey(id);
-		if (parsed === null) continue;
-		const stateKey = createBfcacheSegmentIdentity(id, parsed, {
-			metadata,
-			pathname: normalizedPathname
-		});
-		if (stateKey !== null) stateKeys[id] = stateKey;
-	}
-	return stateKeys;
+function createBfcacheSegmentIdentityMap(options) {
+	return readAppElementsMetadata(options.elements)?.bfcacheSegmentIdentities ?? {};
 }
 function createInitialBfcacheMaps(options) {
-	const metadata = indexAppElementsMetadata(options.metadata);
-	const ids = collectBfcacheSegmentIdCandidates(options.elements, metadata);
-	const normalizedPathname = normalizeBfcachePathname(options.pathname);
+	const metadata = options.metadata;
 	const bfcacheIds = {};
-	const stateKeys = {};
-	for (const id of ids) {
-		const parsed = parseBfcacheSegmentKey(id);
-		if (parsed === null) continue;
-		bfcacheIds[id] = "0";
-		const stateKey = createBfcacheSegmentIdentity(id, parsed, {
-			metadata,
-			pathname: normalizedPathname
-		});
-		if (stateKey !== null) stateKeys[id] = stateKey;
-	}
+	for (const id of collectBfcacheSegmentIds(options.elements, metadata)) bfcacheIds[id] = "0";
 	return {
 		bfcacheIds,
-		stateKeys
+		identities: metadata.bfcacheSegmentIdentities
 	};
 }
 function createNextBfcacheIdMap(options) {
@@ -122,20 +51,12 @@ function createNextBfcacheIdMap(options) {
 	for (const value of Object.values(options.restored ?? {})) rememberBfcacheId(value);
 	const currentMetadata = readAppElementsMetadata(options.currentElements);
 	const nextMetadata = readAppElementsMetadata(options.elements);
-	const currentPathname = normalizeBfcachePathname(options.currentPathname);
-	const nextPathname = normalizeBfcachePathname(options.nextPathname);
 	const ids = {};
-	for (const id of collectBfcacheSegmentIdCandidates(options.elements, nextMetadata)) {
-		const parsed = parseBfcacheSegmentKey(id);
-		if (parsed === null) continue;
-		const currentValue = createBfcacheSegmentIdentity(id, parsed, {
-			metadata: currentMetadata,
-			pathname: currentPathname
-		}) === createBfcacheSegmentIdentity(id, parsed, {
-			metadata: nextMetadata,
-			pathname: nextPathname
-		}) ? current[id] : void 0;
-		const value = options.restored?.[id] ?? currentValue ?? mintBfcacheId();
+	for (const id of collectBfcacheSegmentIds(options.elements, nextMetadata)) {
+		const currentIdentity = currentMetadata?.bfcacheSegmentIdentities[id];
+		const nextIdentity = nextMetadata?.bfcacheSegmentIdentities[id];
+		const currentValue = currentIdentity !== void 0 && currentIdentity === nextIdentity ? current[id] : void 0;
+		const value = (nextIdentity === void 0 ? void 0 : options.restored?.[id]) ?? currentValue ?? mintBfcacheId();
 		ids[id] = value;
 		rememberBfcacheId(value);
 	}
@@ -143,9 +64,13 @@ function createNextBfcacheIdMap(options) {
 }
 function preserveBfcacheIdsForMergedElements(options) {
 	const ids = {};
-	for (const id of collectBfcacheSegmentIdCandidates(options.elements)) {
-		if (parseBfcacheSegmentKey(id) === null) continue;
-		const value = options.next[id] ?? options.previous[id];
+	const preservePreviousIds = new Set(options.preservePreviousIds ?? []);
+	const preservedElementIds = new Set(options.preservedElementIds ?? []);
+	const preservedParentIds = [...preservedElementIds];
+	const identities = createBfcacheSegmentIdentityMap({ elements: options.elements });
+	for (const id of collectBfcacheSegmentIds(options.elements)) {
+		const isPreservedNestedSegment = preservedParentIds.some((parentId) => isNestedBfcacheSlotSegmentIdFor(id, parentId));
+		const value = (preservedElementIds.has(id) || isPreservedNestedSegment) && identities[id] === void 0 ? mintBfcacheId() : preservePreviousIds.has(id) || isPreservedNestedSegment ? options.previous[id] ?? options.next[id] : options.next[id] ?? options.previous[id];
 		if (value === void 0) continue;
 		ids[id] = value;
 		rememberBfcacheId(value);
@@ -153,4 +78,4 @@ function preserveBfcacheIdsForMergedElements(options) {
 	return ids;
 }
 //#endregion
-export { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };
+export { createBfcacheSegmentIdentityMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };

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

@@ -1,6 +1,5 @@
 import { OperationLane } from "./operation-token.js";
 import { ServerActionResultFacts } from "./navigation-planner.js";
-
 //#region src/server/app-browser-action-result.d.ts
 type AppBrowserServerActionResult<TRoot> = {
   root?: TRoot;