vinext 0.1.5 → 0.1.7

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 };

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

@@ -18,14 +18,15 @@ import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscR
 import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import "../client/instrumentation-client.js";
-import { readHistoryStatePreviousNextUrl } from "./app-history-state.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 { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext } from "./app-browser-interception-context.js";
+import { readHistoryStatePreviousNextUrl } from "./app-history-state.js";
 import { AppBrowserMpaNavigationScheduler } from "./app-browser-mpa-navigation.js";
+import { blockDangerousStreamedRscRedirect } from "./app-browser-rsc-redirect.js";
 import { navigationPlanner } from "./navigation-planner.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, isCacheRestorableAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl, resolveServerActionRequestState } from "./app-browser-state.js";
 import { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch } from "./app-browser-navigation-controller.js";
@@ -1032,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),
@@ -1045,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-navigation-controller.js

@@ -1,8 +1,8 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { clearAppNavigationFailureTarget, getAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { claimAppRouterScrollIntentForCommit, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
-import { shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
 import { activateNavigationSnapshot, clearPendingPathname, commitClientNavigationState, createSnapshotPathAndSearch } from "../shims/navigation.js";
+import { shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
 import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, createPendingNavigationCommit } from "./app-browser-state.js";
 import { applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit } from "./app-browser-visible-commit.js";
 import { startTransition, useInsertionEffect, useLayoutEffect } from "react";

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.js

@@ -7,11 +7,11 @@ import { getMountedSlotIds, getMountedSlotIdsHeader } from "./app-elements.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 { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.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 { 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" };

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

@@ -1,8 +1,8 @@
 import { normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { mergeElements } from "../shims/slot.js";
-import { preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.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");

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

@@ -63,7 +63,6 @@ declare function createHistoryStateWithNavigationMetadata(state: unknown, metada
 }): HistoryStateRecord | null;
 declare function createExternalHistoryStatePreservingMetadata(callerState: unknown, currentHistoryState: unknown): unknown;
 declare function readHistoryStatePreviousNextUrl(state: unknown): string | null;
-declare function isBfcacheSegmentId(id: string): boolean;
 declare function readHistoryStateBfcacheIds(state: unknown): BfcacheIdMap | null;
 declare function readHistoryStateBfcacheVersion(state: unknown): number | null;
 /**
@@ -83,4 +82,4 @@ declare function resolveHistoryTraversalIntent(options: {
   historyState: unknown;
 }): HistoryTraversalIntent;
 //#endregion
-export { BfcacheIdMap, HistoryStateSnapshotCache, HistoryTraversalIntent, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
+export { BfcacheIdMap, HistoryStateSnapshotCache, HistoryTraversalIntent, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

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

@@ -220,4 +220,4 @@ function resolveHistoryTraversalIntent(options) {
 	};
 }
 //#endregion
-export { HistoryStateSnapshotCache, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
+export { HistoryStateSnapshotCache, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

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

@@ -117,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-dispatch.d.ts

@@ -31,7 +31,7 @@ type AppPageBackgroundRegenerationErrorContext = {
 };
 type AppPageBackgroundRegenerator = (key: string, renderFn: () => Promise<void>, errorContext?: AppPageBackgroundRegenerationErrorContext) => void;
 type AppPageDispatchIntercept<TPage = unknown> = {
-  interceptLayouts?: readonly AppPageModule[] | null;
+  interceptLayouts?: readonly unknown[] | null;
   matchedParams: AppPageParams;
   page: TPage;
   slotId?: string | null;
@@ -41,7 +41,7 @@ type AppPageDispatchIntercept<TPage = unknown> = {
 };
 type AppPageDispatchInterceptOptions<TPage = unknown> = {
   interceptionContext: string | null;
-  interceptLayouts?: readonly AppPageModule[] | null;
+  interceptLayouts?: readonly unknown[] | null;
   interceptPage: TPage;
   interceptParams: AppPageParams;
   interceptSlotId?: string | null;

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

@@ -1,7 +1,6 @@
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { mergeMetadataEntries, mergeViewport, postProcessMetadata, resolveModuleMetadata as resolveModuleMetadata$1, resolveModuleViewport } from "../shims/metadata.js";
 import { resolveAppPageSegmentParams } from "./app-page-params.js";
-import { applyFileBasedMetadata } from "./file-based-metadata.js";
 import { tagAppPageMetadataError } from "./app-page-execution.js";
 //#region src/server/app-page-head.ts
 /**
@@ -206,7 +205,8 @@ async function resolveAppPageHeadInner(options) {
 	const metadataSources = createMetadataSources(layoutMetadataResults, routeSegments, layoutSourcePositions, pageMetadata, Boolean(options.pageModule));
 	metadataSources.push(...parallelMetadataSources);
 	let metadata = resolvedMetadataBase;
-	try {
+	if (options.metadataRoutes.length > 0) try {
+		const { applyFileBasedMetadata } = await import("./file-based-metadata.js");
 		metadata = await applyFileBasedMetadata(resolvedMetadataBase, options.routePath, options.params, options.metadataRoutes, {
 			routeSegments,
 			metadataSources,

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

@@ -1,6 +1,6 @@
 import { methodNotAllowedResponse } from "./http-error-responses.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
-import { isPossibleAppRouteActionRequest } from "./app-route-handler-policy.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 //#region src/server/app-page-method.ts
 function isNonGetOrHead(method) {
 	const normalizedMethod = method.toUpperCase();

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

@@ -39,9 +39,16 @@ type BuildAppPageElementResult<TElement> = {
   response: Response | null;
 };
 type AppPageInterceptMatch<TPage = unknown> = {
+  interceptLayouts?: readonly unknown[] | null;
+  __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   matchedParams: AppPageParams;
   page: TPage;
   __pageLoader?: (() => Promise<TPage>) | null;
+  __loadState?: {
+    page: TPage;
+    pageLoading: Promise<TPage> | null;
+    interceptLayoutsLoading: Promise<readonly unknown[]> | null;
+  };
   slotId?: string | null;
   slotKey: string;
   sourceRouteIndex: number;

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

@@ -1,6 +1,7 @@
 import { notFoundResponse } from "./http-error-responses.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { getAppPageSegmentParamName } from "./app-page-params.js";
+import { loadAppInterceptLayouts } from "./app-route-module-loader.js";
 //#region src/server/app-page-request.ts
 function pickRouteParams(matchedParams, routeParamNames) {
 	const params = {};
@@ -104,7 +105,24 @@ async function resolveAppPageInterceptState(options) {
 	if (!options.isRscRequest) return { kind: "none" };
 	const intercept = options.findIntercept(options.cleanPathname);
 	if (!intercept) return { kind: "none" };
-	if (intercept.__pageLoader && intercept.page == null) intercept.page = await intercept.__pageLoader();
+	const loadState = intercept.__loadState;
+	if (loadState?.page != null) intercept.page = loadState.page;
+	if (intercept.__pageLoader && intercept.page == null) {
+		const loading = loadState?.pageLoading ?? intercept.__pageLoader().then((page) => {
+			intercept.page = page;
+			if (loadState) {
+				loadState.page = page;
+				loadState.pageLoading = null;
+			}
+			return page;
+		}).catch((error) => {
+			if (loadState) loadState.pageLoading = null;
+			throw error;
+		});
+		if (loadState) loadState.pageLoading = loading;
+		await loading;
+	}
+	if (intercept.__loadInterceptLayouts) await loadAppInterceptLayouts(intercept);
 	const sourceRoute = await options.getSourceRoute(intercept.sourceRouteIndex);
 	if (!sourceRoute) return { kind: "none" };
 	if (sourceRoute === options.currentRoute) return {

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

@@ -1,3 +1,4 @@
+import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
@@ -131,7 +132,7 @@ function createAppPageRscErrorTracker(baseOnError) {
 			return capturedSpecialError;
 		},
 		onRenderError(error, requestInfo, errorContext) {
-			if (error && typeof error === "object" && "digest" in error) {
+			if (isNavigationSignalError(error)) {
 				if (capturedSpecialError === null) capturedSpecialError = error;
 			} else capturedError = error;
 			return baseOnError(error, requestInfo, errorContext);

package/dist/server/app-prerender-endpoints.d.ts

@@ -5,14 +5,14 @@ type GenerateStaticParams = (args: {
   params: RootParams;
 }) => unknown;
 type AppPrerenderStaticParamsMap = Record<string, GenerateStaticParams | null | undefined>;
-type RootParamNamesMap = Record<string, readonly string[] | undefined>;
+type AppPrerenderRootParamNamesMap = Record<string, readonly string[] | undefined>;
 type HandleAppPrerenderEndpointOptions = {
   isPrerenderEnabled?: () => boolean;
   loadPagesRoutes?: () => Promise<unknown>;
   pathname: string;
-  rootParamNamesByPattern?: RootParamNamesMap;
+  rootParamNamesByPattern?: AppPrerenderRootParamNamesMap;
   staticParamsMap: AppPrerenderStaticParamsMap;
 };
 declare function handleAppPrerenderEndpoint(request: Request, options: HandleAppPrerenderEndpointOptions): Promise<Response | null>;
 //#endregion
-export { handleAppPrerenderEndpoint };
+export { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap, handleAppPrerenderEndpoint };

package/dist/server/app-prerender-endpoints.js

@@ -1,12 +1,11 @@
+import "./headers.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { callAppPrerenderStaticParams } from "./app-prerender-static-params.js";
 //#region src/server/app-prerender-endpoints.ts
-const STATIC_PARAMS_ENDPOINT = "/__vinext/prerender/static-params";
-const PAGES_STATIC_PATHS_ENDPOINT = "/__vinext/prerender/pages-static-paths";
 const JSON_HEADERS = { "content-type": "application/json" };
 async function handleAppPrerenderEndpoint(request, options) {
-	if (options.pathname === STATIC_PARAMS_ENDPOINT) return handleStaticParamsEndpoint(request, options);
-	if (options.pathname === PAGES_STATIC_PATHS_ENDPOINT) {
+	if (options.pathname === "/__vinext/prerender/static-params") return handleStaticParamsEndpoint(request, options);
+	if (options.pathname === "/__vinext/prerender/pages-static-paths") {
 		if (!options.loadPagesRoutes) return null;
 		return handlePagesStaticPathsEndpoint(request, options);
 	}

package/dist/server/app-route-handler-cache.js

@@ -1,6 +1,6 @@
 import { makeThenableParams } from "../shims/thenable-params.js";
-import { markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { applyRouteHandlerMiddlewareContext, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
+import { markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { runAppRouteHandler } from "./app-route-handler-execution.js";
 //#region src/server/app-route-handler-cache.ts
 const EMPTY_PARAMS = Object.freeze({});

package/dist/server/app-route-handler-dispatch.js

@@ -7,10 +7,10 @@ import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import "../shims/navigation.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
-import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
-import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { applyRouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
+import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
+import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { executeAppRouteHandler } from "./app-route-handler-execution.js";
 import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
 import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";

package/dist/server/app-route-handler-execution.js

@@ -1,8 +1,9 @@
 import { setHeadersContext } from "../shims/headers.js";
-import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
-import { isPossibleAppRouteActionRequest, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
+import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
+import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
 //#region src/server/app-route-handler-execution.ts
 function configureAppRouteStaticGenerationContext(options) {
 	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") {

package/dist/server/app-route-handler-policy.d.ts

@@ -1,3 +1,4 @@
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { RouteHandlerHttpMethod, RouteHandlerModule } from "./app-route-handler-runtime.js";
 
 //#region src/server/app-route-handler-policy.d.ts
@@ -43,7 +44,6 @@ type AppRouteHandlerSpecialError = {
 type AppRouteHandlerSpecialErrorOptions = {
   isAction: boolean;
 };
-declare function isPossibleAppRouteActionRequest(request: Pick<Request, "headers" | "method">): boolean;
 declare function getAppRouteHandlerRevalidateSeconds(handler: Pick<AppRouteHandlerModule, "revalidate">): number | null;
 declare function hasAppRouteHandlerDefaultExport(handler: RouteHandlerModule): boolean;
 declare function resolveAppRouteHandlerMethod(handler: AppRouteHandlerModule, method: string): ResolvedAppRouteHandlerMethod;

package/dist/server/app-route-handler-policy.js

@@ -1,12 +1,7 @@
-import "./headers.js";
 import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { buildRouteHandlerAllowHeader, collectRouteHandlerMethods } from "./app-route-handler-runtime.js";
 //#region src/server/app-route-handler-policy.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;
-}
 function getAppRouteHandlerRevalidateSeconds(handler) {
 	const { revalidate } = handler;
 	if (revalidate === false) return Infinity;

package/dist/server/app-route-module-loader.d.ts

@@ -10,34 +10,82 @@
  * module at Worker startup. Only the module(s) for the matched route are
  * evaluated, on demand.
  *
- * `ensureAppRouteModulesLoaded` resolves a route's lazy thunks and populates the
- * synchronous `page` / `routeHandler` fields that the rest of the request
- * pipeline reads directly. It is:
+ * `ensureAppRouteModulesLoaded` resolves a route's lazy thunks and populates
+ * the synchronous module fields that the rest of the request pipeline reads
+ * directly (`page`, `routeHandler`, layouts, templates, boundaries, and
+ * parallel-slot modules). It is:
  *
  *  - idempotent: once a route is loaded it returns immediately;
  *  - dedup'd: concurrent calls for the same route share one in-flight promise,
  *    so a burst of requests to the same route triggers a single import.
  *
- * Callers must `await` it before any synchronous read of `route.page` or
- * `route.routeHandler` (segment config, fetch-cache mode, runtime resolution,
- * dispatch branch, element building, etc.).
+ * Callers must `await` it before any synchronous read of route modules
+ * (segment config, fetch-cache mode, runtime resolution, dispatch branch,
+ * element building, etc.).
  */
 type LazyModuleThunk = () => Promise<unknown>;
+type LazyModuleLoaderArray = readonly (LazyModuleThunk | null | undefined)[];
+type LazyLoadableIntercept = {
+  interceptLayouts?: readonly unknown[] | null;
+  __loadInterceptLayouts?: LazyModuleLoaderArray | null;
+  __loadState?: {
+    interceptLayoutsLoading: Promise<readonly unknown[]> | null;
+  };
+};
+type LazyLoadableSlot = {
+  page?: unknown;
+  default?: unknown;
+  layout?: unknown;
+  loading?: unknown;
+  error?: unknown;
+  __loadPage?: LazyModuleThunk | null;
+  __loadDefault?: LazyModuleThunk | null;
+  __loadLayout?: LazyModuleThunk | null;
+  __loadLoading?: LazyModuleThunk | null;
+  __loadError?: LazyModuleThunk | null; /** Hydrated only after an intercept matches, not with the slot's base modules. */
+  intercepts?: LazyLoadableIntercept[];
+};
 type LazyLoadableRoute = {
   page?: unknown;
-  routeHandler?: unknown; /** Lazy loader for the page module; `null`/absent when the page is eager. */
+  routeHandler?: unknown;
+  layouts?: unknown[];
+  templates?: unknown[];
+  errors?: unknown[];
+  errorPaths?: unknown[];
+  notFounds?: unknown[];
+  forbiddens?: unknown[];
+  unauthorizeds?: unknown[];
+  loading?: unknown;
+  error?: unknown;
+  notFound?: unknown;
+  forbidden?: unknown;
+  unauthorized?: unknown;
+  slots?: Record<string, LazyLoadableSlot>;
+  siblingIntercepts?: LazyLoadableIntercept[]; /** Lazy loader for the page module; `null`/absent when the page is eager. */
   __loadPage?: LazyModuleThunk | null; /** Lazy loader for the route-handler module; `null`/absent when none. */
-  __loadRouteHandler?: LazyModuleThunk | null; /** Set once the lazy modules have been resolved onto `page`/`routeHandler`. */
+  __loadRouteHandler?: LazyModuleThunk | null;
+  __loadLayouts?: LazyModuleLoaderArray | null;
+  __loadTemplates?: LazyModuleLoaderArray | null;
+  __loadErrors?: LazyModuleLoaderArray | null;
+  __loadErrorPaths?: LazyModuleLoaderArray | null;
+  __loadNotFounds?: LazyModuleLoaderArray | null;
+  __loadForbiddens?: LazyModuleLoaderArray | null;
+  __loadUnauthorizeds?: LazyModuleLoaderArray | null;
+  __loadLoading?: LazyModuleThunk | null;
+  __loadError?: LazyModuleThunk | null;
+  __loadNotFound?: LazyModuleThunk | null;
+  __loadForbidden?: LazyModuleThunk | null;
+  __loadUnauthorized?: LazyModuleThunk | null; /** Set once the route's lazy module fields have been resolved. */
   __loaded?: boolean; /** In-flight hydration promise, used to dedup concurrent loads. */
   __loading?: Promise<unknown> | null;
 };
+declare function loadAppInterceptLayouts(intercept: LazyLoadableIntercept): Promise<readonly unknown[]>;
 /**
- * Resolve a route's lazy page/route-handler modules and assign them onto the
- * route's synchronous `page` / `routeHandler` fields. Returns the same route
- * reference (synchronously when already loaded, otherwise after the in-flight
- * import resolves). Safe to call on `null`/`undefined` routes and on eager
- * routes that have no lazy thunks.
+ * Resolve a route's lazy modules and assign them onto the route's synchronous
+ * module fields. Returns the same route reference (synchronously when already
+ * loaded, otherwise after the in-flight import resolves). Safe to call on
+ * `null`/`undefined` routes and on eager routes that have no lazy thunks.
  */
 declare function ensureAppRouteModulesLoaded<TRoute extends LazyLoadableRoute>(route: TRoute | null | undefined): TRoute | Promise<TRoute>;
 //#endregion
-export { LazyLoadableRoute, ensureAppRouteModulesLoaded };
+export { LazyLoadableRoute, ensureAppRouteModulesLoaded, loadAppInterceptLayouts };