vinext 0.1.5 → 0.1.6

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

package/dist/server/app-route-module-loader.js

@@ -1,23 +1,74 @@
 //#region src/server/app-route-module-loader.ts
+function pushFieldLoad(loads, target, field, loader) {
+	if (!loader || target[field] != null) return;
+	loads.push(loader().then((module) => {
+		target[field] = module;
+	}));
+}
+function pushArrayLoads(loads, target, loaders) {
+	if (!target || !loaders) return;
+	const slots = target;
+	for (const [index, loader] of loaders.entries()) {
+		if (index >= slots.length || !loader || slots[index] != null) continue;
+		loads.push(loader().then((module) => {
+			slots[index] = module;
+		}));
+	}
+}
+function loadAppInterceptLayouts(intercept) {
+	const loadState = intercept.__loadState;
+	if (loadState?.interceptLayoutsLoading) return loadState.interceptLayoutsLoading;
+	const loads = [];
+	pushArrayLoads(loads, intercept.interceptLayouts, intercept.__loadInterceptLayouts);
+	if (loads.length === 0) return Promise.resolve(intercept.interceptLayouts ?? []);
+	const loading = Promise.all(loads).then(() => {
+		if (loadState) loadState.interceptLayoutsLoading = null;
+		return intercept.interceptLayouts ?? [];
+	}).catch((error) => {
+		if (loadState) loadState.interceptLayoutsLoading = null;
+		throw error;
+	});
+	if (loadState) loadState.interceptLayoutsLoading = loading;
+	return loading;
+}
 /**
-* 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.
 */
 function ensureAppRouteModulesLoaded(route) {
 	if (!route || route.__loaded) return route;
 	if (route.__loading) return route.__loading;
 	const loadPage = route.__loadPage;
 	const loadRouteHandler = route.__loadRouteHandler;
-	if (!loadPage && !loadRouteHandler) {
+	const loads = [];
+	pushFieldLoad(loads, route, "page", loadPage);
+	pushFieldLoad(loads, route, "routeHandler", loadRouteHandler);
+	pushFieldLoad(loads, route, "loading", route.__loadLoading);
+	pushFieldLoad(loads, route, "error", route.__loadError);
+	pushFieldLoad(loads, route, "notFound", route.__loadNotFound);
+	pushFieldLoad(loads, route, "forbidden", route.__loadForbidden);
+	pushFieldLoad(loads, route, "unauthorized", route.__loadUnauthorized);
+	pushArrayLoads(loads, route.layouts, route.__loadLayouts);
+	pushArrayLoads(loads, route.templates, route.__loadTemplates);
+	pushArrayLoads(loads, route.errors, route.__loadErrors);
+	pushArrayLoads(loads, route.errorPaths, route.__loadErrorPaths);
+	pushArrayLoads(loads, route.notFounds, route.__loadNotFounds);
+	pushArrayLoads(loads, route.forbiddens, route.__loadForbiddens);
+	pushArrayLoads(loads, route.unauthorizeds, route.__loadUnauthorizeds);
+	for (const slot of Object.values(route.slots ?? {})) {
+		pushFieldLoad(loads, slot, "page", slot.__loadPage);
+		pushFieldLoad(loads, slot, "default", slot.__loadDefault);
+		pushFieldLoad(loads, slot, "layout", slot.__loadLayout);
+		pushFieldLoad(loads, slot, "loading", slot.__loadLoading);
+		pushFieldLoad(loads, slot, "error", slot.__loadError);
+	}
+	if (loads.length === 0) {
 		route.__loaded = true;
 		return route;
 	}
-	const loading = Promise.all([loadPage ? loadPage() : void 0, loadRouteHandler ? loadRouteHandler() : void 0]).then(([pageModule, routeHandlerModule]) => {
-		if (loadPage) route.page = pageModule;
-		if (loadRouteHandler) route.routeHandler = routeHandlerModule;
+	const loading = Promise.all(loads).then(() => {
 		route.__loaded = true;
 		route.__loading = null;
 		return route;
@@ -29,4 +80,4 @@ function ensureAppRouteModulesLoaded(route) {
 	return loading;
 }
 //#endregion
-export { ensureAppRouteModulesLoaded };
+export { ensureAppRouteModulesLoaded, loadAppInterceptLayouts };

package/dist/server/app-rsc-handler.d.ts

@@ -5,16 +5,16 @@ import { RootParams } from "../shims/root-params.js";
 import { MiddlewareModule } from "./middleware-runtime.js";
 import { AppMiddlewareContext } from "./app-middleware.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
-import { handleAppPrerenderEndpoint } from "./app-prerender-endpoints.js";
-import { handleMetadataRouteRequest } from "./metadata-route-response.js";
+import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
+import { MetadataRouteMakeThenableParams, MetadataRuntimeRoute } from "./metadata-route-response.js";
 import { ReactFormState } from "react-dom/client";
 
 //#region src/server/app-rsc-handler.d.ts
 type AppPageParams = Record<string, string | string[]>;
-type MetadataRoutes = Parameters<typeof handleMetadataRouteRequest>[0]["metadataRoutes"];
-type MakeThenableParams = Parameters<typeof handleMetadataRouteRequest>[0]["makeThenableParams"];
-type StaticParamsMap = Parameters<typeof handleAppPrerenderEndpoint>[1]["staticParamsMap"];
-type RootParamNamesMap = Parameters<typeof handleAppPrerenderEndpoint>[1]["rootParamNamesByPattern"];
+type MetadataRoutes = readonly MetadataRuntimeRoute[];
+type MakeThenableParams = MetadataRouteMakeThenableParams;
+type StaticParamsMap = AppPrerenderStaticParamsMap;
+type RootParamNamesMap = AppPrerenderRootParamNamesMap;
 type AppRscMiddlewareContext = AppMiddlewareContext;
 type AppRscHandlerRoute = {
   isDynamic: boolean;
@@ -183,6 +183,7 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   makeThenableParams: MakeThenableParams;
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   metadataRoutes: MetadataRoutes;
+  middlewareFilePath: string | null;
   middlewareModule: MiddlewareModule | null;
   publicFiles: ReadonlySet<string>;
   renderNotFound: (options: RenderNotFoundOptions<TRoute>) => Promise<Response | null>;

package/dist/server/app-rsc-handler.js

@@ -17,14 +17,12 @@ import "./app-page-response.js";
 import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
+import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { flattenErrorCauses } from "../utils/error-cause.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
-import { pickRootParams, setRootParams } from "../shims/root-params.js";
-import { handleAppPrerenderEndpoint } from "./app-prerender-endpoints.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
-import { handleMetadataRouteRequest } from "./metadata-route-response.js";
 import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
 //#region src/server/app-rsc-handler.ts
 const STATIC_METADATA_CONFIG_HEADER_OVERRIDES = new Set(["cache-control"]);
@@ -125,16 +123,19 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		basePath: options.basePath,
 		hadBasePath: true
 	};
-	const prerenderEndpointResponse = await handleAppPrerenderEndpoint(request, {
-		isPrerenderEnabled() {
-			return process.env.VINEXT_PRERENDER === "1";
-		},
-		loadPagesRoutes: options.loadPrerenderPagesRoutes,
-		pathname,
-		rootParamNamesByPattern: options.rootParamNamesByPattern,
-		staticParamsMap: options.staticParamsMap
-	});
-	if (prerenderEndpointResponse) return prerenderEndpointResponse;
+	if (pathname === "/__vinext/prerender/static-params" || pathname === "/__vinext/prerender/pages-static-paths") {
+		const { handleAppPrerenderEndpoint } = await import("./app-prerender-endpoints.js");
+		const prerenderEndpointResponse = await handleAppPrerenderEndpoint(request, {
+			isPrerenderEnabled() {
+				return process.env.VINEXT_PRERENDER === "1";
+			},
+			loadPagesRoutes: options.loadPrerenderPagesRoutes,
+			pathname,
+			rootParamNamesByPattern: options.rootParamNamesByPattern,
+			staticParamsMap: options.staticParamsMap
+		});
+		if (prerenderEndpointResponse) return prerenderEndpointResponse;
+	}
 	const trailingSlashRedirect = normalizeTrailingSlash(pathname, options.basePath, options.trailingSlash, url.search);
 	if (trailingSlashRedirect) return trailingSlashRedirect;
 	const matchPathname = (p) => normalizeDefaultLocalePathname(p, options.i18nConfig, { hostname: url.hostname });
@@ -170,6 +171,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			basePath: options.basePath,
 			cleanPathname,
 			context: middlewareContext,
+			filePath: options.middlewareFilePath ?? void 0,
 			i18nConfig: options.i18nConfig,
 			isDataRequest,
 			isProxy: options.isMiddlewareProxy,
@@ -209,20 +211,23 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!imageRedirect) return new Response("Invalid image optimization parameters", { status: 400 });
 		return Response.redirect(new URL(imageRedirect, url.origin).href, 302);
 	}
-	const metadataRouteResponse = await handleMetadataRouteRequest({
-		metadataRoutes: options.metadataRoutes,
-		cleanPathname,
-		makeThenableParams: options.makeThenableParams
-	});
-	if (metadataRouteResponse) {
-		applyConfigHeadersToResponse(metadataRouteResponse.headers, {
-			basePathState,
-			configHeaders: options.configHeaders,
-			overwriteExisting: STATIC_METADATA_CONFIG_HEADER_OVERRIDES,
-			pathname: matchPathname(cleanPathname),
-			requestContext: preMiddlewareRequestContext
+	if (options.metadataRoutes.length > 0) {
+		const { handleMetadataRouteRequest } = await import("./metadata-route-response.js");
+		const metadataRouteResponse = await handleMetadataRouteRequest({
+			metadataRoutes: options.metadataRoutes,
+			cleanPathname,
+			makeThenableParams: options.makeThenableParams
 		});
-		return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
+		if (metadataRouteResponse) {
+			applyConfigHeadersToResponse(metadataRouteResponse.headers, {
+				basePathState,
+				configHeaders: options.configHeaders,
+				overwriteExisting: STATIC_METADATA_CONFIG_HEADER_OVERRIDES,
+				pathname: matchPathname(cleanPathname),
+				requestContext: preMiddlewareRequestContext
+			});
+			return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
+		}
 	}
 	const publicFileResponse = resolvePublicFileRoute({
 		cleanPathname,

package/dist/server/app-rsc-route-matching.d.ts

@@ -31,6 +31,7 @@ type AppRscInterceptForMatching = {
   sourceMatchPattern?: string;
   sourcePageSegments?: readonly string[];
   interceptLayouts: readonly unknown[];
+  __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   params: readonly string[];
@@ -45,6 +46,7 @@ type AppRscSiblingInterceptForMatching = {
   sourcePageSegments?: readonly string[];
   slotId: string | null;
   interceptLayouts: readonly unknown[];
+  __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   params: readonly string[];
@@ -58,6 +60,11 @@ type AppRscRouteForMatching = {
 type AppRscInterceptMatch = AppRscInterceptLookupEntry & {
   matchedParams: AppRscRouteParams;
 };
+type AppRscInterceptLoadState = {
+  page: unknown;
+  pageLoading: Promise<unknown> | null;
+  interceptLayoutsLoading: Promise<readonly unknown[]> | null;
+};
 type AppRscInterceptLookupEntry = {
   sourceRouteIndex: number;
   slotKey: string;
@@ -67,8 +74,10 @@ type AppRscInterceptLookupEntry = {
   sourceMatchPatternParts: string[] | null;
   sourcePageSegments: readonly string[] | null;
   interceptLayouts: readonly unknown[];
+  __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
+  __loadState: AppRscInterceptLoadState;
   params: readonly string[];
   slotId: string | null;
 };

package/dist/server/app-rsc-route-matching.js

@@ -39,6 +39,7 @@ function createAppRscRouteMatcher(routes) {
 				const sourceParams = matchedSourceParams ?? createRouteParams();
 				return {
 					...entry,
+					page: entry.__loadState.page,
 					sourceRouteIndex: concreteSourceRouteIndex,
 					matchedParams: mergeMatchedParams(sourceParams, params)
 				};
@@ -84,8 +85,14 @@ function createInterceptLookup(routes) {
 					sourceMatchPatternParts,
 					sourcePageSegments: intercept.sourcePageSegments ?? null,
 					interceptLayouts: intercept.interceptLayouts,
+					__loadInterceptLayouts: intercept.__loadInterceptLayouts,
 					page: intercept.page,
 					__pageLoader: intercept.__pageLoader,
+					__loadState: {
+						page: intercept.page,
+						pageLoading: null,
+						interceptLayoutsLoading: null
+					},
 					params: intercept.params
 				});
 			}
@@ -103,8 +110,14 @@ function createInterceptLookup(routes) {
 				sourceMatchPatternParts,
 				sourcePageSegments: intercept.sourcePageSegments ?? null,
 				interceptLayouts: intercept.interceptLayouts,
+				__loadInterceptLayouts: intercept.__loadInterceptLayouts,
 				page: intercept.page,
 				__pageLoader: intercept.__pageLoader,
+				__loadState: {
+					page: intercept.page,
+					pageLoading: null,
+					interceptLayoutsLoading: null
+				},
 				params: intercept.params
 			});
 		}