vinext 0.1.4 → 0.1.6

package/dist/server/accept-encoding.js

@@ -0,0 +1,95 @@
+import zlib from "node:zlib";
+//#region src/server/accept-encoding.ts
+/** Parse an Accept-Encoding header into exact-token numeric qualities. */
+function parseAcceptedEncodings(accept) {
+	const qualities = /* @__PURE__ */ new Map();
+	const orders = /* @__PURE__ */ new Map();
+	let wildcardQuality = null;
+	for (const [order, part] of accept.split(",").entries()) {
+		const trimmed = part.trim();
+		if (trimmed.length === 0) continue;
+		const semi = trimmed.indexOf(";");
+		const token = (semi === -1 ? trimmed : trimmed.slice(0, semi)).trim().toLowerCase();
+		if (token.length === 0) continue;
+		let quality = 1;
+		if (semi !== -1) {
+			let qStr;
+			for (const param of trimmed.slice(semi + 1).split(";")) {
+				const [name, value] = param.trim().split("=");
+				if (name !== "q") continue;
+				qStr = value ?? "";
+				break;
+			}
+			if (qStr !== void 0) quality = Number.parseFloat(qStr);
+		}
+		if (token === "*") {
+			if (wildcardQuality === null || Number.isNaN(quality) || Number.isNaN(wildcardQuality) || quality >= wildcardQuality) wildcardQuality = quality;
+		} else {
+			const currentQuality = qualities.get(token);
+			if (currentQuality === void 0 || Number.isNaN(quality) || Number.isNaN(currentQuality) || quality >= currentQuality) {
+				qualities.set(token, quality);
+				orders.set(token, order);
+			}
+		}
+	}
+	return {
+		qualities,
+		orders,
+		wildcardQuality
+	};
+}
+/** Return the effective quality for a coding, including wildcard/identity rules. */
+function getEncodingQuality(parsed, encoding) {
+	const normalized = encoding.toLowerCase();
+	const explicit = parsed.qualities.get(normalized);
+	if (explicit !== void 0) return Number.isNaN(explicit) ? 0 : explicit;
+	if (normalized === "identity") return parsed.wildcardQuality === 0 ? 0 : 1;
+	if (parsed.wildcardQuality !== null) return Number.isNaN(parsed.wildcardQuality) ? 0 : parsed.wildcardQuality;
+	return 0;
+}
+function isEncodingAccepted(parsed, encoding) {
+	return getEncodingQuality(parsed, encoding) > 0;
+}
+/** Choose the highest-quality available coding, using array order as the tie-breaker. */
+function selectAcceptedEncoding(parsed, available) {
+	let selected = null;
+	let selectedQuality = 0;
+	for (const encoding of available) {
+		const quality = getEncodingQuality(parsed, encoding);
+		if (quality > selectedQuality) {
+			selected = encoding;
+			selectedQuality = quality;
+		}
+	}
+	return selected;
+}
+/**
+* Select a content coding while matching Next.js's compression middleware:
+* an explicit identity preference can win, but implicit identity remains a
+* fallback rather than suppressing an otherwise acceptable encoding.
+*/
+function selectContentEncoding(parsed, available) {
+	const selected = selectAcceptedEncoding(parsed, available);
+	if (selected === null) return "identity";
+	const identityQuality = parsed.qualities.get("identity");
+	if (identityQuality === void 0 || Number.isNaN(identityQuality)) return selected;
+	const selectedQuality = getEncodingQuality(parsed, selected);
+	if (identityQuality > selectedQuality) return "identity";
+	if (identityQuality < selectedQuality) return selected;
+	if (!parsed.qualities.has(selected)) return "identity";
+	return (parsed.orders.get("identity") ?? Number.POSITIVE_INFINITY) < (parsed.orders.get(selected) ?? Number.POSITIVE_INFINITY) ? "identity" : selected;
+}
+const HAS_ZSTD = typeof zlib.createZstdCompress === "function";
+/** Select by client q-value first, then zstd > br > gzip > deflate > identity. */
+function negotiateEncoding(req) {
+	const accept = req.headers["accept-encoding"];
+	if (typeof accept !== "string") return "identity";
+	return selectContentEncoding(parseAcceptedEncodings(accept), [
+		...HAS_ZSTD ? ["zstd"] : [],
+		"br",
+		"gzip",
+		"deflate"
+	]);
+}
+//#endregion
+export { HAS_ZSTD, getEncodingQuality, isEncodingAccepted, negotiateEncoding, parseAcceptedEncodings, selectAcceptedEncoding, selectContentEncoding };

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

@@ -0,0 +1,26 @@
+import { AppElements } 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>>;
+declare function createInitialBfcacheIdMap(elements: AppElements): BfcacheIdMap;
+declare function createBfcacheSegmentStateKeyMap(options: {
+  elements: AppElements;
+  pathname: string;
+}): BfcacheStateKeyMap;
+declare function createNextBfcacheIdMap(options: {
+  current: BfcacheIdMap;
+  currentElements: AppElements;
+  currentPathname: string;
+  elements: AppElements;
+  nextPathname: string;
+  restored?: BfcacheIdMap | null;
+  reuseCurrent?: boolean;
+}): BfcacheIdMap;
+declare function preserveBfcacheIdsForMergedElements(options: {
+  elements: AppElements;
+  next: BfcacheIdMap;
+  previous: BfcacheIdMap;
+}): BfcacheIdMap;
+//#endregion
+export { BfcacheStateKeyMap, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };

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

@@ -0,0 +1,127 @@
+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 "./app-bfcache-id.js";
+import { isBfcacheSegmentId } from "./app-history-state.js";
+//#region src/server/app-bfcache-identity.ts
+let nextBfcacheId = 0;
+function rememberBfcacheId(value) {
+	const match = /^_b_(\d+)_$/.exec(value);
+	if (!match) return;
+	nextBfcacheId = Math.max(nextBfcacheId, Number(match[1]));
+}
+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 readAppElementsMetadata(elements) {
+	let metadata;
+	try {
+		metadata = AppElementsWire.readMetadata(elements);
+	} catch {
+		return null;
+	}
+	const slotBindingsBySlotId = /* @__PURE__ */ new Map();
+	for (const binding of metadata.slotBindings) slotBindingsBySlotId.set(binding.slotId, binding);
+	return {
+		metadata,
+		slotBindingsBySlotId
+	};
+}
+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, options) {
+	const parsed = AppElementsWire.parseElementKey(id);
+	if (!parsed) return null;
+	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 collectBfcacheSegmentIds(elements, parsed) {
+	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);
+}
+function createInitialBfcacheIdMap(elements) {
+	const ids = {};
+	for (const id of collectBfcacheSegmentIds(elements)) ids[id] = "0";
+	return ids;
+}
+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 collectBfcacheSegmentIds(options.elements, metadata)) {
+		const stateKey = createBfcacheSegmentIdentity(id, {
+			metadata,
+			pathname: normalizedPathname
+		});
+		if (stateKey !== null) stateKeys[id] = stateKey;
+	}
+	return stateKeys;
+}
+function createNextBfcacheIdMap(options) {
+	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);
+	const currentPathname = normalizeBfcachePathname(options.currentPathname);
+	const nextPathname = normalizeBfcachePathname(options.nextPathname);
+	const ids = {};
+	for (const id of collectBfcacheSegmentIds(options.elements, nextMetadata)) {
+		const currentValue = createBfcacheSegmentIdentity(id, {
+			metadata: currentMetadata,
+			pathname: currentPathname
+		}) === createBfcacheSegmentIdentity(id, {
+			metadata: nextMetadata,
+			pathname: nextPathname
+		}) ? current[id] : void 0;
+		const value = options.restored?.[id] ?? currentValue ?? mintBfcacheId();
+		ids[id] = value;
+		rememberBfcacheId(value);
+	}
+	return ids;
+}
+function preserveBfcacheIdsForMergedElements(options) {
+	const ids = {};
+	for (const id of collectBfcacheSegmentIds(options.elements)) {
+		const value = options.next[id] ?? options.previous[id];
+		if (value === void 0) continue;
+		ids[id] = value;
+		rememberBfcacheId(value);
+	}
+	return ids;
+}
+//#endregion
+export { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };

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

@@ -6,25 +6,29 @@ import { getMountedSlotIdsHeader, resolveVisitedResponseInterceptionContext } fr
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { installWindowNext, setWindowNextInternalSourcePage } from "../client/window-next.js";
 import { retryScrollTo, scrollToHashTargetOnNextFrame } from "../shims/hash-scroll.js";
+import { getBfcacheIdMapContext, setNavigationContext } from "../shims/navigation-context-state.js";
+import { decodeRedirectError, isRedirectError } from "../shims/navigation-errors.js";
+import DefaultGlobalError from "../shims/default-global-error.js";
+import { clearAppNavigationFailureTarget, installAppNavigationFailureListeners } from "../client/app-nav-failure-handler.js";
+import { DevRecoveryBoundary, GlobalErrorBoundary, RedirectBoundary } from "../shims/error-boundary.js";
+import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
+import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
+import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
 import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
-import { clearAppNavigationFailureTarget, installAppNavigationFailureListeners } from "../client/app-nav-failure-handler.js";
+import "../client/instrumentation-client.js";
 import { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext } from "./app-browser-interception-context.js";
 import { readHistoryStatePreviousNextUrl } from "./app-history-state.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
 import { AppBrowserMpaNavigationScheduler } from "./app-browser-mpa-navigation.js";
+import { blockDangerousStreamedRscRedirect } from "./app-browser-rsc-redirect.js";
 import { navigationPlanner } from "./navigation-planner.js";
-import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
-import { __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, decodeRedirectError, getBfcacheIdMapContext, getClientNavigationRenderContext, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, isRedirectError, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, useRouter } from "../shims/navigation.js";
-import DefaultGlobalError from "../shims/default-global-error.js";
-import { DevRecoveryBoundary, GlobalErrorBoundary, RedirectBoundary } from "../shims/error-boundary.js";
-import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
-import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
-import "../client/instrumentation-client.js";
+import { __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, getClientNavigationRenderContext, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, setClientParams, setMountedSlotsHeader, setPendingPathname, useRouter } from "../shims/navigation.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-bfcache-identity.js";
 import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
 import { createClientReuseManifestHeaderFromVisibleAppState } from "./app-browser-client-reuse-manifest.js";
 import { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal } from "./app-browser-stream.js";
-import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, isCacheRestorableAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl, resolveServerActionRequestState } from "./app-browser-state.js";
+import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, isCacheRestorableAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl, resolveServerActionRequestState } from "./app-browser-state.js";
 import { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch } from "./app-browser-navigation-controller.js";
 import { applyServerActionResultDecision } from "./app-browser-server-action-navigation.js";
 import { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition } from "./app-browser-hydration.js";
@@ -1029,6 +1033,8 @@ function bootstrapHydration(rscStream) {
 					}
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					const navContentType = navResponse.headers.get("content-type") ?? "";
+					const streamedRedirectTarget = navResponse.headers.get(VINEXT_RSC_REDIRECT_HEADER);
+					if (blockDangerousStreamedRscRedirect(navResponse, streamedRedirectTarget)) return;
 					const liveFetchDecision = navigationPlanner.classifyRscFetchResult({
 						clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
 						compatibilityIdHeader: navResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
@@ -1042,7 +1048,7 @@ function bootstrapHydration(rscStream) {
 						responseOk: navResponse.ok,
 						responseUrl: navResponseUrl ?? navResponse.url,
 						source: "live",
-						streamedRedirectTarget: navResponse.headers.get(VINEXT_RSC_REDIRECT_HEADER)
+						streamedRedirectTarget
 					});
 					if (liveFetchDecision.kind === "hardNavigate") {
 						if (liveFetchDecision.discardBody) navResponse.body?.cancel().catch(() => {});

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

@@ -1,4 +1,5 @@
 //#region src/server/app-browser-rsc-redirect.d.ts
+declare function blockDangerousStreamedRscRedirect(response: Response, streamedRedirectTarget: string | null): boolean;
 type RscRedirectHistoryUpdateMode = "push" | "replace" | undefined;
 type RscRedirectLifecycleDecision = {
   href: string;
@@ -34,4 +35,4 @@ declare function resolveStreamedRscRedirectLifecycleHop(options: {
   streamedRedirectTarget: string;
 }): RscRedirectLifecycleDecision;
 //#endregion
-export { resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop };
+export { blockDangerousStreamedRscRedirect, resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop };

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

@@ -1,6 +1,13 @@
+import { isDangerousScheme, reportBlockedDangerousNavigation } from "../shims/url-safety.js";
 import { resolveHardNavigationTargetFromRscResponse, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 //#region src/server/app-browser-rsc-redirect.ts
 const MAX_RSC_REDIRECT_DEPTH = 10;
+function blockDangerousStreamedRscRedirect(response, streamedRedirectTarget) {
+	if (streamedRedirectTarget === null || !isDangerousScheme(streamedRedirectTarget)) return false;
+	response.body?.cancel().catch(() => {});
+	reportBlockedDangerousNavigation();
+	return true;
+}
 function toVisibleAppHref(href, origin) {
 	const url = new URL(href, origin);
 	stripRscCacheBustingSearchParam(url);
@@ -54,4 +61,4 @@ function resolveStreamedRscRedirectLifecycleHop(options) {
 	});
 }
 //#endregion
-export { resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop };
+export { blockDangerousStreamedRscRedirect, resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop };

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

@@ -3,8 +3,9 @@ import { CacheEntryReuseProof } from "./cache-proof.js";
 import { AppElements, AppElementsInterception, AppElementsSlotBinding, LayoutFlags } from "./app-elements-wire.js";
 import { NavigationTrace } from "./navigation-trace.js";
 import { OperationLane } from "./operation-token.js";
-import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 import { BfcacheIdMap, HistoryTraversalIntent, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
+import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 
 //#region src/server/app-browser-state.d.ts
 type OperationRecordBase = {
@@ -70,7 +71,6 @@ type AppNavigationPayloadOrigin = Readonly<{
 } | {
   origin: "visited-cache";
 }>;
-type BfcacheStateKeyMap = Readonly<Record<string, string>>;
 declare const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN: AppNavigationPayloadOrigin;
 declare const VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN: AppNavigationPayloadOrigin;
 type PendingNavigationCommitDisposition = "dispatch" | "hard-navigate" | "skip";
@@ -91,25 +91,6 @@ type NonDispatchPendingNavigationCommitDispositionDecision = {
   trace: NavigationTrace;
 };
 type PendingNavigationCommitDispositionDecision = DispatchPendingNavigationCommitDispositionDecision | NonDispatchPendingNavigationCommitDispositionDecision;
-declare function createInitialBfcacheIdMap(elements: AppElements): BfcacheIdMap;
-declare function createBfcacheSegmentStateKeyMap(options: {
-  elements: AppElements;
-  pathname: string;
-}): BfcacheStateKeyMap;
-declare function createNextBfcacheIdMap(options: {
-  current: BfcacheIdMap;
-  currentElements: AppElements;
-  currentPathname: string;
-  elements: AppElements;
-  nextPathname: string;
-  restored?: BfcacheIdMap | null;
-  reuseCurrent?: boolean;
-}): BfcacheIdMap;
-declare function preserveBfcacheIdsForMergedElements(options: {
-  elements: AppElements;
-  next: BfcacheIdMap;
-  previous: BfcacheIdMap;
-}): BfcacheIdMap;
 declare function isCacheRestorableAppPayloadMetadata(metadata: CacheRestorableAppPayloadMetadata): metadata is CacheRestorableAppPayloadMetadata & {
   cacheEntryReuseProof: CacheEntryReuseProof;
 };

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

@@ -1,144 +1,20 @@
-import { countConsumedPathnameSegments, isInvisibleSegment, normalizePathnameForRouteMatch, splitPathSegments } from "../routing/utils.js";
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
 import { NEXT_ACTION_HEADER, RSC_ACTION_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 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 { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { verifyOperationTokenForCommit } from "./operation-token.js";
 import { navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts } from "./navigation-planner.js";
 import { createSnapshotPathAndSearch } from "../shims/navigation.js";
-import { createCacheEntryReuseProof } from "./cache-proof.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.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" };
-let nextBfcacheId = 0;
-function rememberBfcacheId(value) {
-	const match = /^_b_(\d+)_$/.exec(value);
-	if (!match) return;
-	nextBfcacheId = Math.max(nextBfcacheId, Number(match[1]));
-}
-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 readAppElementsMetadata(elements) {
-	let metadata;
-	try {
-		metadata = AppElementsWire.readMetadata(elements);
-	} catch {
-		return null;
-	}
-	const slotBindingsBySlotId = /* @__PURE__ */ new Map();
-	for (const binding of metadata.slotBindings) slotBindingsBySlotId.set(binding.slotId, binding);
-	return {
-		metadata,
-		slotBindingsBySlotId
-	};
-}
-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}`;
-}
-/**
-* Legacy bridge for deriving a bfcache segment identity from AppElements wire
-* keys. Keep wire-key parsing contained here until Vinext has a route-manifest
-* semantic authority equivalent to Next.js CacheNode/segment-cache state.
-*/
-function createBfcacheSegmentIdentity(id, options) {
-	const parsed = AppElementsWire.parseElementKey(id);
-	if (!parsed) return null;
-	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 collectBfcacheSegmentIds(elements, parsed) {
-	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);
-}
-function createInitialBfcacheIdMap(elements) {
-	const ids = {};
-	for (const id of collectBfcacheSegmentIds(elements)) ids[id] = "0";
-	return ids;
-}
-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 collectBfcacheSegmentIds(options.elements, metadata)) {
-		const stateKey = createBfcacheSegmentIdentity(id, {
-			metadata,
-			pathname: normalizedPathname
-		});
-		if (stateKey !== null) stateKeys[id] = stateKey;
-	}
-	return stateKeys;
-}
-function createNextBfcacheIdMap(options) {
-	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);
-	const currentPathname = normalizeBfcachePathname(options.currentPathname);
-	const nextPathname = normalizeBfcachePathname(options.nextPathname);
-	const ids = {};
-	for (const id of collectBfcacheSegmentIds(options.elements, nextMetadata)) {
-		const currentValue = createBfcacheSegmentIdentity(id, {
-			metadata: currentMetadata,
-			pathname: currentPathname
-		}) === createBfcacheSegmentIdentity(id, {
-			metadata: nextMetadata,
-			pathname: nextPathname
-		}) ? current[id] : void 0;
-		const value = options.restored?.[id] ?? currentValue ?? mintBfcacheId();
-		ids[id] = value;
-		rememberBfcacheId(value);
-	}
-	return ids;
-}
-function preserveBfcacheIdsForMergedElements(options) {
-	const ids = {};
-	for (const id of collectBfcacheSegmentIds(options.elements)) {
-		const nextValue = options.next[id];
-		if (nextValue !== void 0) {
-			ids[id] = nextValue;
-			continue;
-		}
-		const previousValue = options.previous[id];
-		if (previousValue !== void 0) {
-			ids[id] = previousValue;
-			rememberBfcacheId(previousValue);
-		}
-	}
-	return ids;
-}
 function createOperationRecord(options) {
 	return {
 		id: options.id,

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

@@ -1,5 +1,5 @@
-import { ensureNavigationRuntimeRscBootstrap, getNavigationRuntime } from "../client/navigation-runtime.js";
 import { decodeRscEmbeddedChunk } from "./app-rsc-embedded-chunks.js";
+import { ensureNavigationRuntimeRscBootstrap, getNavigationRuntime } from "../client/navigation-runtime.js";
 //#region src/server/app-browser-stream.ts
 function getVinextBrowserGlobal() {
 	return globalThis;

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

@@ -1,8 +1,9 @@
 import { normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.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";
+import { NavigationTraceReasonCodes, NavigationTraceTransactionCodes, createNavigationTrace, prependNavigationTraceEntry } from "./navigation-trace.js";
+import { preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
+import { createPendingNavigationCommit, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
 //#region src/server/app-browser-visible-commit.ts
 const approvedVisibleCommitBrand = Symbol("ApprovedVisibleCommit");
 function applyApprovedVisibleCommit(state, commit) {

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

@@ -1,6 +1,6 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppElements } from "./app-elements-wire.js";
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";

package/dist/server/app-layout-param-observation.d.ts

@@ -1,5 +1,5 @@
+import { UnstableCacheObservation } from "../shims/cache-request-state.js";
 import { RenderRequestApiKind } from "./cache-proof.js";
-import { UnstableCacheObservation } from "../shims/cache.js";
 import { ClientReuseManifestRejectionCode, ClientReuseManifestTraceFields } from "./client-reuse-manifest.js";
 import { ThenableParamsObserver } from "../shims/thenable-params.js";
 

package/dist/server/app-layout-param-observation.js

@@ -1,6 +1,6 @@
 import { isInsideUnifiedScope, runWithUnifiedStateMutation } from "../shims/unified-request-context.js";
 import { peekDynamicUsage, peekRenderRequestApiUsage } from "../shims/headers.js";
-import { _peekRequestScopedCacheLife, _peekUnstableCacheObservations } from "../shims/cache.js";
+import { _peekRequestScopedCacheLife, _peekUnstableCacheObservations } from "../shims/cache-request-state.js";
 import { getCollectedFetchTags, peekCacheableFetchObservations, peekDynamicFetchObservations } from "../shims/fetch-cache.js";
 import { isPromiseLike } from "../utils/promise.js";
 //#region src/server/app-layout-param-observation.ts

package/dist/server/app-middleware.d.ts

@@ -19,6 +19,7 @@ type ApplyAppMiddlewareOptions = {
    * INTERNAL_HEADERS and is stripped before this function runs.
    */
   isDataRequest?: boolean;
+  filePath?: string;
   isProxy: boolean;
   module: MiddlewareModule;
   request: Request;

package/dist/server/app-middleware.js

@@ -5,8 +5,9 @@ import { internalServerErrorResponse } from "./http-error-responses.js";
 import { cloneRequestWithHeaders, processMiddlewareHeaders } from "./request-pipeline.js";
 import { executeMiddleware } from "./middleware-runtime.js";
 import { applyMiddlewareRequestHeaders, setHeadersContext } from "../shims/headers.js";
-import { setNavigationContext } from "../shims/navigation.js";
+import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import "../shims/navigation.js";
 //#region src/server/app-middleware.ts
 const FLIGHT_HEADER_SET = new Set(FLIGHT_HEADERS);
 function isForwardedMiddlewareContext(value) {
@@ -116,6 +117,7 @@ async function applyAppMiddleware(options) {
 		const result = await executeMiddleware({
 			basePath: options.basePath,
 			hadBasePath: true,
+			filePath: options.filePath,
 			i18nConfig: options.i18nConfig,
 			isDataRequest: options.isDataRequest,
 			isProxy: options.isProxy,

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

@@ -1,6 +1,6 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppElements } from "./app-elements-wire.js";
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";

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

@@ -1,6 +1,6 @@
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { resolveAppPageSegmentParams } from "./app-page-params.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 //#region src/server/app-page-boundary.ts