vinext 0.1.6 → 0.1.8

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

@@ -1,5 +1,5 @@
-import { normalizePathSeparators } from "../utils/path.js";
 import { decodeRouteSegment, isInvisibleSegment, sortRoutes } from "./utils.js";
+import { normalizePathSeparators } from "../utils/path.js";
 import { findFileWithExts, scanWithExtensions } from "./file-matcher.js";
 import { validateRoutePatterns } from "./route-validation.js";
 import { compareStrings } from "../utils/compare.js";
@@ -360,8 +360,8 @@ async function buildAppRouteGraph(appDir, matcher) {
 	const routePatterns = new Set(routes.map((route) => route.pattern));
 	const ghostParentRoutes = [];
 	for await (const file of scanWithExtensions("**/layout", appDir, scanMatcher.extensions, excludeDir)) {
-		const dir = path.dirname(file);
-		const routeDir = dir === "." ? appDir : path.join(appDir, dir);
+		const dir = path.posix.dirname(file);
+		const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
 		if (!hasParallelSlotDirectory(routeDir)) continue;
 		if (discoverParallelSlots(routeDir, appDir, scanMatcher).length === 0) continue;
 		const route = directoryToAppRoute(dir, appDir, scanMatcher, null, null);
@@ -434,11 +434,16 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 	const applySlotSubPages = (route, slotPages, rawSegments) => {
 		route.parallelSlots = route.parallelSlots.map((slot) => {
 			const subPage = slotPages.get(slot.key);
-			if (subPage !== void 0) return {
-				...slot,
-				pagePath: subPage,
-				routeSegments: rawSegments
-			};
+			if (subPage !== void 0) {
+				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
+				return {
+					...slot,
+					pagePath: subPage,
+					configLayoutPaths,
+					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					routeSegments: rawSegments
+				};
+			}
 			return slot;
 		});
 	};
@@ -495,9 +500,12 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			if (Array.from(routesByPattern.values()).some((r) => patternsStructurallyEquivalent(r.patternParts, syntheticParts))) continue;
 			const subSlots = parentRoute.parallelSlots.map((slot) => {
 				const subPage = slotPages.get(slot.key);
+				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
 				return {
 					...slot,
 					pagePath: subPage || null,
+					configLayoutPaths,
+					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
 					routeSegments: subPage ? rawSegments : null
 				};
 			});
@@ -574,6 +582,23 @@ function findSlotSubPages(slotDir, matcher) {
 	perMatcher.set(slotDir, results);
 	return results;
 }
+function findSlotConfigLayoutPaths(slotDir, pagePath, matcher) {
+	if (!pagePath) return [];
+	const layouts = [];
+	let dir = path.dirname(pagePath);
+	while (dir !== slotDir && dir.startsWith(`${slotDir}${path.sep}`)) {
+		const layoutPath = findFile(dir, "layout", matcher);
+		if (layoutPath) layouts.unshift(layoutPath);
+		dir = path.dirname(dir);
+	}
+	return layouts;
+}
+function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
+	return layoutPaths.map((layoutPath) => {
+		const relativeDir = path.relative(slotDir, path.dirname(layoutPath));
+		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
+	});
+}
 /**
 * Find a sibling catch-all page directly under `dir`, i.e. a `[...slug]` or
 * `[[...slug]]` directory that contains a `page` file. Returns the absolute
@@ -613,8 +638,14 @@ function fileToAppRoute(file, appDir, type, matcher) {
 	}
 	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.join(appDir, file) : null, type === "route" ? path.join(appDir, file) : null);
 }
+/**
+* `dir` and `appDir` must both be forward-slash. `dir` is split on
+* `path.posix.sep` and joined onto `appDir` with `path.posix.join`, and `appDir`
+* is threaded to the layout/slot/boundary discovery below, which build paths the
+* same way.
+*/
 function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
-	const segments = dir === "." ? [] : dir.split(path.sep);
+	const segments = dir === "." ? [] : dir.split(path.posix.sep);
 	const params = [];
 	let isDynamic = false;
 	const convertedRoute = convertSegmentsToRouteParts(segments);
@@ -631,7 +662,7 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 	const errorEntries = discoverSegmentErrors(segments, appDir, matcher);
 	const errorPaths = errorEntries.map((entry) => entry.path);
 	const errorTreePositions = errorEntries.map((entry) => entry.treePosition);
-	const routeDir = dir === "." ? appDir : path.join(appDir, dir);
+	const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
 	const loadingPath = findFile(routeDir, "loading", matcher);
 	const errorPath = findFile(routeDir, "error", matcher);
 	const notFoundPath = discoverBoundaryFile(segments, appDir, "not-found", matcher);
@@ -863,6 +894,10 @@ function discoverBoundaryFilePerLayout(layouts, fileName, matcher) {
 * Walk from appDir through each segment to the route's directory. At each level
 * that has @slot dirs, collect them. Slots at the route's own directory level
 * use page.tsx; slots at ancestor levels use default.tsx only.
+*
+* `appDir` and `routeDir` must be forward-slash — `currentDir` descends from
+* `appDir` via `path.posix.join`, and the `dir === routeDir` active-level test
+* below only matches when both share the canonical separator.
 */
 function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 	const slotMap = /* @__PURE__ */ new Map();
@@ -875,7 +910,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 		segmentIndex: 0
 	});
 	for (let i = 0; i < segments.length; i++) {
-		currentDir = path.join(currentDir, segments[i]);
+		currentDir = path.posix.join(currentDir, segments[i]);
 		if (findFile(currentDir, "layout", matcher)) layoutIdx++;
 		dirsToCheck.push({
 			dir: currentDir,
@@ -902,9 +937,12 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 				slotPatternParts = [...ownerUrl?.urlSegments ?? [], ...mirror.slotUrlSegments];
 				slotParamNames = [...ownerUrl?.params ?? [], ...mirror.slotParamNames];
 			}
+			const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, mirror?.pagePath ?? null, matcher);
 			const inheritedSlot = {
 				...slot,
 				pagePath: mirror?.pagePath ?? null,
+				configLayoutPaths,
+				configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
 				layoutIndex: slotLayoutIdx,
 				routeSegments: mirror?.segments ?? null,
 				slotPatternParts,
@@ -1035,6 +1073,9 @@ function patternsStructurallyEquivalent(a, b) {
 *
 * Returns the absolute page path, or null if no root-level page is found.
 *
+* `slotDir` must be forward-slash: the `path.posix.join` descent stays a
+* canonical id only when the base already is.
+*
 * Only descends into route-group directories (those whose name starts with `(`
 * and ends with `)`). Dynamic segments, regular named dirs, and `@slot` dirs
 * are not transparent and are therefore not searched.
@@ -1051,7 +1092,7 @@ function findSlotRootPage(slotDir, matcher) {
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (!entry.name.startsWith("(") || !entry.name.endsWith(")")) continue;
-		const found = findSlotRootPage(path.join(slotDir, entry.name), matcher);
+		const found = findSlotRootPage(path.posix.join(slotDir, entry.name), matcher);
 		if (found) return found;
 	}
 	return null;
@@ -1068,13 +1109,14 @@ function discoverParallelSlots(dir, appDir, matcher) {
 		if (!entry.isDirectory() || !entry.name.startsWith("@")) continue;
 		if (entry.name === "@children") continue;
 		const slotName = entry.name.slice(1);
-		const slotDir = path.join(dir, entry.name);
+		const slotDir = path.posix.join(dir, entry.name);
 		const pagePath = findSlotRootPage(slotDir, matcher);
 		const defaultPath = findFile(slotDir, "default", matcher);
 		const interceptingRoutes = discoverInterceptingRoutes(slotDir, dir, appDir, matcher);
 		if (!pagePath && !defaultPath && interceptingRoutes.length === 0) continue;
 		const ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
+		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
 			key: `${slotName}@${path.relative(appDir, slotDir).replace(/\\/g, "/")}`,
@@ -1085,6 +1127,8 @@ function discoverParallelSlots(dir, appDir, matcher) {
 			pagePath,
 			defaultPath,
 			layoutPath: findFile(slotDir, "layout", matcher),
+			configLayoutPaths,
+			configLayoutTreePositions: findSlotConfigLayoutTreePositions(slotDir, configLayoutPaths),
 			loadingPath: findFile(slotDir, "loading", matcher),
 			errorPath: findFile(slotDir, "error", matcher),
 			interceptingRoutes,
@@ -1272,8 +1316,12 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
 			results.push({
+				branchSegments: [interceptSegment, ...normalizePathSeparators(path.relative(interceptRoot, path.dirname(page))).split("/").filter(Boolean)],
 				convention,
 				layoutPaths: [...layoutPaths],
+				layoutSegments: layoutPaths.map((layoutPath) => {
+					return [interceptSegment, ...path.relative(interceptRoot, path.dirname(layoutPath)).split(path.sep).filter(Boolean)];
+				}),
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,

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

@@ -12,11 +12,16 @@ declare function invalidateAppRouteCache(): void;
  * TODO(#726): Layer 4 should consume this read model directly once the
  * navigation planner owns route graph facts.
  *
+ * `appDir` must be forward-slash — callers normalize it at their entry, and it
+ * flows into `buildAppRouteGraph`, which builds every path with `path.posix.*`.
+ *
  * @internal
  */
 declare function appRouteGraph(appDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<AppRouteGraph>;
 /**
  * Scan the app/ directory and return a list of routes.
+ *
+ * `appDir` must be forward-slash — it is forwarded to `appRouteGraph`.
  */
 declare function appRouter(appDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<AppRouteGraphRoute[]>;
 /**

package/dist/routing/app-router.js

@@ -30,6 +30,9 @@ function invalidateAppRouteCache() {
 * TODO(#726): Layer 4 should consume this read model directly once the
 * navigation planner owns route graph facts.
 *
+* `appDir` must be forward-slash — callers normalize it at their entry, and it
+* flows into `buildAppRouteGraph`, which builds every path with `path.posix.*`.
+*
 * @internal
 */
 async function appRouteGraph(appDir, pageExtensions, matcher) {
@@ -44,6 +47,8 @@ async function appRouteGraph(appDir, pageExtensions, matcher) {
 }
 /**
 * Scan the app/ directory and return a list of routes.
+*
+* `appDir` must be forward-slash — it is forwarded to `appRouteGraph`.
 */
 async function appRouter(appDir, pageExtensions, matcher) {
 	return (await appRouteGraph(appDir, pageExtensions, matcher)).routes;

package/dist/routing/file-matcher.d.ts

@@ -54,6 +54,11 @@ declare function buildViteResolveExtensions(pageExtensions?: readonly string[] |
 declare function normalizeViteResolveExtensions(extensions: readonly string[]): string[];
 /**
  * Use function-form exclude for Node < 22.14 compatibility.
+ *
+ * Yields forward-slash relative paths: node's glob emits native (backslash)
+ * separators on Windows, so each match is normalized — this is the entry point
+ * that lets downstream consumers treat the scanned paths as canonical
+ * forward-slash ids.
  */
 declare function scanWithExtensions(stem: string, cwd: string, extensions: readonly string[], exclude?: (name: string) => boolean): AsyncGenerator<string>;
 //#endregion

package/dist/routing/file-matcher.js

@@ -1,4 +1,5 @@
 import { escapeRegExp } from "../utils/regex.js";
+import { normalizePathSeparators } from "../utils/path.js";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { glob } from "node:fs/promises";
@@ -135,13 +136,18 @@ function normalizeViteResolveExtensions(extensions) {
 }
 /**
 * Use function-form exclude for Node < 22.14 compatibility.
+*
+* Yields forward-slash relative paths: node's glob emits native (backslash)
+* separators on Windows, so each match is normalized — this is the entry point
+* that lets downstream consumers treat the scanned paths as canonical
+* forward-slash ids.
 */
 async function* scanWithExtensions(stem, cwd, extensions, exclude) {
 	const pattern = buildExtensionGlob(stem, extensions);
 	for await (const file of glob(pattern, {
 		cwd,
 		...exclude ? { exclude } : {}
-	})) yield file;
+	})) yield normalizePathSeparators(file);
 }
 //#endregion
 export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };

package/dist/server/app-action-request.d.ts

@@ -0,0 +1,4 @@
+//#region src/server/app-action-request.d.ts
+declare function isPossibleAppRouteActionRequest(request: Pick<Request, "headers" | "method">): boolean;
+//#endregion
+export { isPossibleAppRouteActionRequest };

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

@@ -0,0 +1,9 @@
+import "./headers.js";
+//#region src/server/app-action-request.ts
+function isPossibleAppRouteActionRequest(request) {
+	if (request.method.toUpperCase() !== "POST") return false;
+	const contentType = request.headers.get("content-type");
+	return request.headers.has("x-rsc-action") || request.headers.has("next-action") || contentType === "application/x-www-form-urlencoded" || contentType?.startsWith("multipart/form-data") === true;
+}
+//#endregion
+export { isPossibleAppRouteActionRequest };

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

@@ -1,13 +1,23 @@
-import { AppElements } from "./app-elements-wire.js";
+import { AppElements, AppElementsWire } from "./app-elements-wire.js";
 import { BfcacheIdMap } from "./app-history-state.js";
 
 //#region src/server/app-bfcache-identity.d.ts
 type BfcacheStateKeyMap = Readonly<Record<string, string>>;
+type InitialBfcacheMaps = Readonly<{
+  bfcacheIds: BfcacheIdMap;
+  stateKeys: BfcacheStateKeyMap;
+}>;
+type AppElementsMetadata = ReturnType<typeof AppElementsWire.readMetadata>;
 declare function createInitialBfcacheIdMap(elements: AppElements): BfcacheIdMap;
 declare function createBfcacheSegmentStateKeyMap(options: {
   elements: AppElements;
   pathname: string;
 }): BfcacheStateKeyMap;
+declare function createInitialBfcacheMaps(options: {
+  elements: AppElements;
+  metadata: AppElementsMetadata;
+  pathname: string;
+}): InitialBfcacheMaps;
 declare function createNextBfcacheIdMap(options: {
   current: BfcacheIdMap;
   currentElements: AppElements;
@@ -23,4 +33,4 @@ declare function preserveBfcacheIdsForMergedElements(options: {
   previous: BfcacheIdMap;
 }): BfcacheIdMap;
 //#endregion
-export { BfcacheStateKeyMap, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };
+export { BfcacheStateKeyMap, InitialBfcacheMaps, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };

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

@@ -3,7 +3,6 @@ import { normalizePath } from "./normalize-path.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.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) {
@@ -24,6 +23,14 @@ function getTreePathIdentityPrefix(pathname, treePath) {
 	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 {
@@ -31,12 +38,11 @@ function readAppElementsMetadata(elements) {
 	} catch {
 		return null;
 	}
-	const slotBindingsBySlotId = /* @__PURE__ */ new Map();
-	for (const binding of metadata.slotBindings) slotBindingsBySlotId.set(binding.slotId, binding);
-	return {
-		metadata,
-		slotBindingsBySlotId
-	};
+	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);
@@ -50,9 +56,7 @@ function createActiveSlotIdentity(id, parsed) {
 * contained here until vinext has a route-manifest authority equivalent to
 * Next.js CacheNode or segment-cache state.
 */
-function createBfcacheSegmentIdentity(id, options) {
-	const parsed = AppElementsWire.parseElementKey(id);
-	if (!parsed) return null;
+function createBfcacheSegmentIdentity(id, parsed, options) {
 	if (parsed.kind === "page") return `${id}@${options.pathname}`;
 	if (parsed.kind === "slot") {
 		const activeSlotIdentity = createActiveSlotIdentity(id, options.metadata);
@@ -62,16 +66,15 @@ function createBfcacheSegmentIdentity(id, options) {
 	if (parsed.kind === "layout" || parsed.kind === "template") return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
 	return null;
 }
-function collectBfcacheSegmentIds(elements, parsed) {
+function collectBfcacheSegmentIdCandidates(elements, metadata = readAppElementsMetadata(elements)) {
 	const ids = new Set(Object.keys(elements));
-	const metadata = parsed === void 0 ? readAppElementsMetadata(elements) : parsed;
 	for (const layoutId of metadata?.metadata.layoutIds ?? []) ids.add(layoutId);
-	return Array.from(ids).filter(isBfcacheSegmentId);
+	return ids;
 }
 function createInitialBfcacheIdMap(elements) {
-	const ids = {};
-	for (const id of collectBfcacheSegmentIds(elements)) ids[id] = "0";
-	return ids;
+	const bfcacheIds = {};
+	for (const id of collectBfcacheSegmentIdCandidates(elements)) if (parseBfcacheSegmentKey(id) !== null) bfcacheIds[id] = "0";
+	return bfcacheIds;
 }
 function normalizeBfcachePathname(pathname) {
 	const normalized = normalizePath(normalizePathnameForRouteMatch(pathname));
@@ -81,8 +84,10 @@ function createBfcacheSegmentStateKeyMap(options) {
 	const metadata = readAppElementsMetadata(options.elements);
 	const normalizedPathname = normalizeBfcachePathname(options.pathname);
 	const stateKeys = {};
-	for (const id of collectBfcacheSegmentIds(options.elements, metadata)) {
-		const stateKey = createBfcacheSegmentIdentity(id, {
+	for (const id of collectBfcacheSegmentIdCandidates(options.elements, metadata)) {
+		const parsed = parseBfcacheSegmentKey(id);
+		if (parsed === null) continue;
+		const stateKey = createBfcacheSegmentIdentity(id, parsed, {
 			metadata,
 			pathname: normalizedPathname
 		});
@@ -90,6 +95,27 @@ function createBfcacheSegmentStateKeyMap(options) {
 	}
 	return stateKeys;
 }
+function createInitialBfcacheMaps(options) {
+	const metadata = indexAppElementsMetadata(options.metadata);
+	const ids = collectBfcacheSegmentIdCandidates(options.elements, metadata);
+	const normalizedPathname = normalizeBfcachePathname(options.pathname);
+	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;
+	}
+	return {
+		bfcacheIds,
+		stateKeys
+	};
+}
 function createNextBfcacheIdMap(options) {
 	const current = options.reuseCurrent === false ? {} : options.current;
 	for (const value of Object.values(current)) rememberBfcacheId(value);
@@ -99,11 +125,13 @@ function createNextBfcacheIdMap(options) {
 	const currentPathname = normalizeBfcachePathname(options.currentPathname);
 	const nextPathname = normalizeBfcachePathname(options.nextPathname);
 	const ids = {};
-	for (const id of collectBfcacheSegmentIds(options.elements, nextMetadata)) {
-		const currentValue = createBfcacheSegmentIdentity(id, {
+	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, {
+		}) === createBfcacheSegmentIdentity(id, parsed, {
 			metadata: nextMetadata,
 			pathname: nextPathname
 		}) ? current[id] : void 0;
@@ -115,7 +143,8 @@ function createNextBfcacheIdMap(options) {
 }
 function preserveBfcacheIdsForMergedElements(options) {
 	const ids = {};
-	for (const id of collectBfcacheSegmentIds(options.elements)) {
+	for (const id of collectBfcacheSegmentIdCandidates(options.elements)) {
+		if (parseBfcacheSegmentKey(id) === null) continue;
 		const value = options.next[id] ?? options.previous[id];
 		if (value === void 0) continue;
 		ids[id] = value;
@@ -124,4 +153,4 @@ function preserveBfcacheIdsForMergedElements(options) {
 	return ids;
 }
 //#endregion
-export { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };
+export { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };