vinext 0.1.4 → 0.1.6

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.d.ts

@@ -1,6 +1,7 @@
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { RootParams } from "../shims/root-params.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { ReactFormState } from "react-dom/client";
 
 //#region src/server/app-page-stream.d.ts
@@ -143,14 +144,6 @@ type AppPageRscErrorTracker = {
 };
 declare function createAppPageFontData(options: CreateAppPageFontDataOptions): AppPageFontData;
 declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<AppSsrRenderResult>;
-/**
- * Wraps a stream so that `onFlush` is called when the last byte has been read
- * by the downstream consumer (i.e. when the HTTP layer finishes draining the
- * response body). This is the correct place to clear per-request context,
- * because the RSC/SSR pipeline is lazy — components execute while the stream
- * is being consumed, not when the stream handle is first obtained.
- */
-declare function deferUntilStreamConsumed(stream: ReadableStream<Uint8Array>, onFlush: () => void): ReadableStream<Uint8Array>;
 declare function renderAppPageHtmlResponse(options: RenderAppPageHtmlResponseOptions): Promise<Response>;
 declare function renderAppPageHtmlStreamWithRecovery<TSpecialError>(options: RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError>): Promise<AppPageHtmlStreamRecoveryResult>;
 declare function createAppPageRscErrorTracker(baseOnError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown): AppPageRscErrorTracker;

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

@@ -1,6 +1,7 @@
 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";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 //#region src/server/app-page-stream.ts
 function isAppSsrRenderResult(value) {
 	return typeof value === "object" && value !== null && "htmlStream" in value && "metadataReady" in value;
@@ -70,41 +71,6 @@ async function renderAppPageHtmlStream(options) {
 	};
 	return normalizeAppSsrRenderResult(await options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions), options.capturedRscDataRef?.value ?? null);
 }
-/**
-* Wraps a stream so that `onFlush` is called when the last byte has been read
-* by the downstream consumer (i.e. when the HTTP layer finishes draining the
-* response body). This is the correct place to clear per-request context,
-* because the RSC/SSR pipeline is lazy — components execute while the stream
-* is being consumed, not when the stream handle is first obtained.
-*/
-function deferUntilStreamConsumed(stream, onFlush) {
-	let called = false;
-	const once = () => {
-		if (!called) {
-			called = true;
-			onFlush();
-		}
-	};
-	const cleanup = new TransformStream({ flush() {
-		once();
-	} });
-	const reader = stream.pipeThrough(cleanup).getReader();
-	return new ReadableStream({
-		pull(controller) {
-			return reader.read().then(({ done, value }) => {
-				if (done) controller.close();
-				else controller.enqueue(value);
-			}, (error) => {
-				once();
-				controller.error(error);
-			});
-		},
-		cancel(reason) {
-			once();
-			return reader.cancel(reason);
-		}
-	});
-}
 async function renderAppPageHtmlResponse(options) {
 	const { htmlStream } = await renderAppPageHtmlStream(options);
 	const safeStream = deferUntilStreamConsumed(htmlStream, () => {

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-request-context.d.ts

@@ -1,5 +1,4 @@
-import { NavigationContext } from "../shims/navigation.js";
-
+import { NavigationContext } from "../shims/navigation-context-state.js";
 //#region src/server/app-request-context.d.ts
 /**
  * Set navigation context in the ALS-backed store. "use client" components

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

@@ -1,5 +1,6 @@
 import { setHeadersContext } from "../shims/headers.js";
-import { setNavigationContext } from "../shims/navigation.js";
+import { setNavigationContext } from "../shims/navigation-context-state.js";
+import "../shims/navigation-server.js";
 import { setRootParams } from "../shims/root-params.js";
 //#region src/server/app-request-context.ts
 /**

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

@@ -3,13 +3,14 @@ import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { consumeDynamicUsage, getAndClearPendingCookies, getDraftModeCookieHeader, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
-import { setNavigationContext } from "../shims/navigation.js";
+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 { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import { applyRouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
+import { createStaticGenerationHeadersContext } from "./app-static-generation.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.d.ts

@@ -1,6 +1,6 @@
 import { NextI18nConfig } from "../config/next-config.js";
+import { CachedRouteValue } from "../shims/cache-handler.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
-import { CachedRouteValue } from "../shims/cache.js";
 import { NextRequest } from "../shims/server.js";
 import { HeadersAccessPhase } from "../shims/headers.js";
 import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";

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

@@ -1,8 +1,8 @@
 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 { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
+import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.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-response.d.ts

@@ -1,4 +1,4 @@
-import { CacheControlMetadata, CachedRouteValue } from "../shims/cache.js";
+import { CacheControlMetadata, CachedRouteValue } from "../shims/cache-handler.js";
 
 //#region src/server/app-route-handler-response.d.ts
 type RouteHandlerMiddlewareContext = {

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

@@ -2,7 +2,8 @@ import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { cloneRequestWithHeaders, filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
+import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";

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

@@ -8,25 +8,21 @@ import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWith
 import { headersContextFromRequest } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { mergeRewriteQuery } from "../utils/query.js";
-import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, resolveDevImageRedirect } from "./image-optimization.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
 import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
-import { createAppPprFallbackShells } from "./app-ppr-fallback-shell.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 { applyAppMiddleware } from "./app-middleware.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.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"]);
@@ -127,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 });
@@ -167,10 +166,12 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	};
 	let didMiddlewareRewrite = false;
 	if (options.middlewareModule) {
+		const { applyAppMiddleware } = await import("./app-middleware.js");
 		const middlewareResult = await applyAppMiddleware({
 			basePath: options.basePath,
 			cleanPathname,
 			context: middlewareContext,
+			filePath: options.middlewareFilePath ?? void 0,
 			i18nConfig: options.i18nConfig,
 			isDataRequest,
 			isProxy: options.isMiddlewareProxy,
@@ -210,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,
@@ -249,7 +253,9 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (preActionMatch) setRootParams(pickRootParams(preActionMatch.params, preActionMatch.route.rootParamNames));
 	const actionId = request.headers.get("x-rsc-action") ?? request.headers.get("next-action");
 	const contentType = request.headers.get("content-type") || "";
-	const progressiveActionResult = await options.handleProgressiveActionRequest({
+	const isPostRequest = request.method.toUpperCase() === "POST";
+	let progressiveActionResult = null;
+	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) progressiveActionResult = await options.handleProgressiveActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -257,12 +263,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		request
 	});
 	if (progressiveActionResult instanceof Response) return progressiveActionResult;
-	const isProgressiveActionRender = progressiveActionResult?.kind === "form-state";
-	const formState = isProgressiveActionRender ? progressiveActionResult.formState : null;
-	const failedProgressiveActionResult = isProgressiveActionRender && "actionFailed" in progressiveActionResult ? progressiveActionResult : null;
+	const progressiveActionFormState = progressiveActionResult?.kind === "form-state" ? progressiveActionResult : null;
+	const isProgressiveActionRender = progressiveActionFormState !== null;
+	const formState = progressiveActionFormState?.formState ?? null;
+	const failedProgressiveActionResult = progressiveActionFormState && "actionError" in progressiveActionFormState ? progressiveActionFormState : null;
 	const actionFailed = failedProgressiveActionResult !== null;
 	const actionError = failedProgressiveActionResult?.actionError;
-	const serverActionResponse = await options.handleServerActionRequest({
+	const serverActionResponse = isPostRequest && actionId ? await options.handleServerActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -272,7 +279,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		mountedSlotsHeader,
 		request,
 		searchParams: getResolvedSearchParams()
-	});
+	}) : null;
 	if (serverActionResponse) return serverActionResponse;
 	let match = preActionMatch;
 	const renderPagesForMatchKind = async (matchKind) => {
@@ -386,11 +393,15 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const isPrerenderFallbackShell = prerenderRouteParamsMatch?.kind === "fallback-shell";
 	const renderParams = prerenderRouteParams ?? params;
 	const resolvedSearchParams = getResolvedSearchParams();
-	const runtimeFallbackShells = options.cacheComponents === true && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params ? createAppPprFallbackShells({
-		params: route.params,
-		pattern: route.pattern,
-		rootParamNames: route.rootParamNames
-	}, params) : [];
+	let runtimeFallbackShells = [];
+	if (options.cacheComponents === true && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) {
+		const { createAppPprFallbackShells } = await import("./app-ppr-fallback-shell.js");
+		runtimeFallbackShells = createAppPprFallbackShells({
+			params: route.params,
+			pattern: route.pattern,
+			rootParamNames: route.rootParamNames
+		}, params);
+	}
 	options.setNavigationContext({
 		pathname: canonicalPathname,
 		searchParams: resolvedSearchParams,
@@ -443,7 +454,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: resolvedSearchParams,
 		renderMode
 	});
-	if (isProgressiveActionRender) return applyProgressiveActionSideEffects(pageResponse, progressiveActionResult);
+	if (isProgressiveActionRender) return applyProgressiveActionSideEffects(pageResponse, progressiveActionFormState);
 	return pageResponse;
 }
 /**

package/dist/server/app-rsc-response-finalizer.js

@@ -4,8 +4,8 @@ import "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { applyConfigHeadersToResponse } from "./request-pipeline.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
-import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { mergeVaryHeader } from "./middleware-response-headers.js";
 //#region src/server/app-rsc-response-finalizer.ts
 /**