vinext 0.1.5 → 0.1.7

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

@@ -19,6 +19,17 @@ type CreateRscOnErrorHandlerOptions = {
 declare function hasDigest(error: unknown): error is {
   digest: unknown;
 };
+/**
+ * vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
+ * string only when the error is a genuine control-flow signal — a redirect,
+ * notFound/HTTP-access fallback, bail-out-to-client-side-rendering, or
+ * dynamic-server-usage throw. Any other digest (e.g. a hashed digest stamped on
+ * a real error, or an obfuscated digest transported from a nested boundary)
+ * returns undefined so the caller still reports it as a real error. Mere
+ * presence of a `digest` field is NOT enough — that conflation swallowed a class
+ * of server render errors with no instrumentation/telemetry.
+ */
+declare function getDigestForWellKnownError(error: unknown): string | undefined;
 /**
  * djb2 hash matching Next.js's string-hash package for RSC error digests.
  */
@@ -26,4 +37,4 @@ declare function errorDigest(input: string): string;
 declare function sanitizeErrorForClient(error: unknown, nodeEnv?: string | undefined): unknown;
 declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
 //#endregion
-export { createRscOnErrorHandler, errorDigest, hasDigest, sanitizeErrorForClient };
+export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };

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

@@ -1,8 +1,26 @@
+import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
 //#region src/server/app-rsc-errors.ts
 function hasDigest(error) {
 	return Boolean(error && typeof error === "object" && "digest" in error);
 }
+const BAILOUT_TO_CSR_DIGEST = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+const DYNAMIC_SERVER_USAGE_DIGEST = "DYNAMIC_SERVER_USAGE";
+/**
+* vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
+* string only when the error is a genuine control-flow signal — a redirect,
+* notFound/HTTP-access fallback, bail-out-to-client-side-rendering, or
+* dynamic-server-usage throw. Any other digest (e.g. a hashed digest stamped on
+* a real error, or an obfuscated digest transported from a nested boundary)
+* returns undefined so the caller still reports it as a real error. Mere
+* presence of a `digest` field is NOT enough — that conflation swallowed a class
+* of server render errors with no instrumentation/telemetry.
+*/
+function getDigestForWellKnownError(error) {
+	if (!hasDigest(error)) return;
+	const digest = String(error.digest);
+	if (isNavigationSignalError(error) || digest === BAILOUT_TO_CSR_DIGEST || digest === DYNAMIC_SERVER_USAGE_DIGEST) return digest;
+}
 function getThrownValueMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -27,14 +45,16 @@ function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 function createRscOnErrorHandler(options) {
 	return (error) => {
 		const nodeEnv = options.nodeEnv ?? process.env.NODE_ENV;
-		if (hasDigest(error)) return String(error.digest);
+		const wellKnownDigest = getDigestForWellKnownError(error);
+		if (wellKnownDigest !== void 0) return wellKnownDigest;
 		if (nodeEnv !== "production" && error instanceof Error && error.message.includes("Only plain objects, and a few built-ins, can be passed to Client Components")) {
 			console.error("[vinext] RSC serialization error: a non-plain object was passed from a Server Component to a Client Component.\n\nCommon causes:\n  * Passing a module namespace (import * as X) directly as a prop.\n    Unlike Next.js (webpack), Vite produces real ESM module namespace objects\n    which are not serializable. Fix: pass individual values instead,\n    e.g. <Comp value={module.value} />\n  * Passing a class instance (new Foo()) as a prop.\n    Fix: convert to a plain object, e.g. { id: foo.id, name: foo.name }\n  * Passing a Date, Map, or Set. Use .toISOString(), [...map.entries()], etc.\n  * Passing Object.create(null). Use { ...obj } to restore a prototype.\n\nOriginal error:", error.message);
 			return;
 		}
 		if (options.requestInfo && options.errorContext && error) options.reportRequestError(error instanceof Error ? error : new Error(getThrownValueMessage(error)), options.requestInfo, options.errorContext);
+		if (hasDigest(error)) return String(error.digest);
 		if (nodeEnv === "production" && error) return errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
 	};
 }
 //#endregion
-export { createRscOnErrorHandler, errorDigest, hasDigest, sanitizeErrorForClient };
+export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };

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

@@ -2,21 +2,25 @@ import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config
 import { ImageConfig } from "./image-optimization.js";
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { RootParams } from "../shims/root-params.js";
-import { MiddlewareModule } from "./middleware-runtime.js";
-import { AppMiddlewareContext } from "./app-middleware.js";
+import { AppMiddlewareContext, ApplyAppMiddlewareResult } 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 { 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 StaticParamsMap = AppPrerenderStaticParamsMap;
+type RootParamNamesMap = AppPrerenderRootParamNamesMap;
 type AppRscMiddlewareContext = AppMiddlewareContext;
+type RunAppMiddlewareOptions = {
+  cleanPathname: string;
+  context: AppRscMiddlewareContext;
+  isDataRequest: boolean;
+  request: Request;
+};
 type AppRscHandlerRoute = {
+  __loadPage?: unknown;
+  __loadRouteHandler?: unknown;
   isDynamic: boolean;
   params?: readonly string[];
   page?: unknown;
@@ -173,17 +177,15 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
    * Node server and dev included, not just the Cloudflare worker entry.
    */
   registerCacheAdapters: (env?: Record<string, unknown>) => void;
-  handleProgressiveActionRequest: (options: HandleProgressiveActionRequestOptions) => Promise<Response | ProgressiveActionFormStateResult | null>;
-  handleServerActionRequest: (options: HandleServerActionRequestOptions) => Promise<Response | null>;
+  handleProgressiveActionRequest?: (options: HandleProgressiveActionRequestOptions) => Promise<Response | ProgressiveActionFormStateResult | null>;
+  handleMetadataRouteRequest?: (cleanPathname: string) => Promise<Response | null>;
+  handleServerActionRequest?: (options: HandleServerActionRequestOptions) => Promise<Response | null>;
   i18nConfig: NextI18nConfig | null;
   imageConfig?: ImageConfig;
   isDev: boolean;
-  isMiddlewareProxy: boolean;
   loadPrerenderPagesRoutes?: () => Promise<unknown>;
-  makeThenableParams: MakeThenableParams;
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
-  metadataRoutes: MetadataRoutes;
-  middlewareModule: MiddlewareModule | null;
+  runMiddleware?: (options: RunAppMiddlewareOptions) => Promise<ApplyAppMiddlewareResult>;
   publicFiles: ReadonlySet<string>;
   renderNotFound: (options: RenderNotFoundOptions<TRoute>) => Promise<Response | null>;
   renderPagesFallback?: (options: RenderPagesFallbackOptions) => Promise<Response | null>;

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

@@ -18,13 +18,12 @@ import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./page
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
 import { flattenErrorCauses } from "../utils/error-cause.js";
+import { pickRootParams, setRootParams } from "../shims/root-params.js";
+import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.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"]);
@@ -49,6 +48,11 @@ function isExecutionContextLike(value) {
 	if (!value || typeof value !== "object") return false;
 	return hasProperty(value, "waitUntil") && typeof value.waitUntil === "function";
 }
+function createMissingServerActionResponse(options, actionId) {
+	console.warn(getServerActionNotFoundMessage(actionId));
+	options.clearRequestContext();
+	return createServerActionNotFoundResponse();
+}
 function redirectDestinationWithBasePath(destination, basePath) {
 	if (!basePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
 	return basePath + destination;
@@ -125,16 +129,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 });
@@ -164,18 +171,12 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		status: null
 	};
 	let didMiddlewareRewrite = false;
-	if (options.middlewareModule) {
-		const { applyAppMiddleware } = await import("./app-middleware.js");
-		const middlewareResult = await applyAppMiddleware({
-			basePath: options.basePath,
+	if (options.runMiddleware) {
+		const middlewareResult = await options.runMiddleware({
 			cleanPathname,
 			context: middlewareContext,
-			i18nConfig: options.i18nConfig,
 			isDataRequest,
-			isProxy: options.isMiddlewareProxy,
-			module: options.middlewareModule,
-			request: userlandRequest,
-			trailingSlash: options.trailingSlash
+			request: userlandRequest
 		});
 		if (middlewareResult.kind === "response") return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
 			basePathState,
@@ -209,20 +210,18 @@ 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
-		});
-		return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
+	if (options.handleMetadataRouteRequest) {
+		const metadataRouteResponse = await options.handleMetadataRouteRequest(cleanPathname);
+		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,
@@ -250,13 +249,16 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const contentType = request.headers.get("content-type") || "";
 	const isPostRequest = request.method.toUpperCase() === "POST";
 	let progressiveActionResult = null;
-	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) progressiveActionResult = await options.handleProgressiveActionRequest({
-		actionId,
-		cleanPathname,
-		contentType,
-		middlewareContext,
-		request
-	});
+	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
+		if (options.handleProgressiveActionRequest) progressiveActionResult = await options.handleProgressiveActionRequest({
+			actionId,
+			cleanPathname,
+			contentType,
+			middlewareContext,
+			request
+		});
+		else if (preActionMatch?.route.__loadPage && !preActionMatch.route.__loadRouteHandler) return createMissingServerActionResponse(options, null);
+	}
 	if (progressiveActionResult instanceof Response) return progressiveActionResult;
 	const progressiveActionFormState = progressiveActionResult?.kind === "form-state" ? progressiveActionResult : null;
 	const isProgressiveActionRender = progressiveActionFormState !== null;
@@ -264,7 +266,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const failedProgressiveActionResult = progressiveActionFormState && "actionError" in progressiveActionFormState ? progressiveActionFormState : null;
 	const actionFailed = failedProgressiveActionResult !== null;
 	const actionError = failedProgressiveActionResult?.actionError;
-	const serverActionResponse = isPostRequest && actionId ? await options.handleServerActionRequest({
+	const serverActionResponse = isPostRequest && actionId && options.handleServerActionRequest ? await options.handleServerActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -276,6 +278,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams()
 	}) : null;
 	if (serverActionResponse) return serverActionResponse;
+	if (isPostRequest && actionId && !options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
 	let match = preActionMatch;
 	const renderPagesForMatchKind = async (matchKind) => {
 		const response = match === null || match.route.isDynamic ? await options.renderPagesFallback?.({

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

@@ -22,7 +22,11 @@ import { mergeVaryHeader } from "./middleware-response-headers.js";
 */
 function finalizeAppRscResponse(response, request, options) {
 	if (response.status >= 300 && response.status < 400) return response;
-	if (!response.headers.has("x-vinext-static-file")) mergeVaryHeader(response.headers, VINEXT_RSC_VARY_HEADER);
+	if (!response.headers.has("x-vinext-static-file")) {
+		const varyHeader = response.headers.get("Vary");
+		if (varyHeader === null) response.headers.set("Vary", VINEXT_RSC_VARY_HEADER);
+		else if (varyHeader !== VINEXT_RSC_VARY_HEADER) mergeVaryHeader(response.headers, VINEXT_RSC_VARY_HEADER);
+	}
 	if (!response.headers.has("Cache-Control")) applyCdnResponseHeaders(response.headers, { cacheControl: "" });
 	if (!options.configHeaders.length) return response;
 	const url = new URL(request.url);

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

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

@@ -377,7 +377,7 @@ async function handleProgressiveServerActionRequest(options) {
 			options.setHeadersAccessPhase(previousHeadersPhase);
 		}
 		if (!actionRedirect) {
-			const actionPendingCookies = options.getAndClearPendingCookies();
+			const actionPendingCookies = dedupePendingCookies(options.getAndClearPendingCookies());
 			const actionDraftCookie = options.getDraftModeCookieHeader();
 			const revalidationKind = resolveActionRevalidationKind(actionPendingCookies.length > 0 || Boolean(actionDraftCookie));
 			if (actionFailed) return {

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

@@ -16,12 +16,12 @@ import DefaultGlobalError from "../shims/default-global-error.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform } from "./app-ssr-stream.js";
-import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-bfcache-identity.js";
+import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
+import { runWithRootParamsScope } from "../shims/root-params.js";
+import { createInitialBfcacheMaps } from "./app-bfcache-identity.js";
 import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
 import { createClientReferencePreloader } from "./app-client-reference-preloader.js";
 import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
-import { runWithRootParamsScope } from "../shims/root-params.js";
-import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
 import { renderBeforeInteractiveInlineScripts } from "./before-interactive-head.js";
 import { createInitialDevServerErrorScript } from "./dev-initial-server-error.js";
 import { ssrAppRouterInstance } from "./app-ssr-router-instance.js";
@@ -186,12 +186,14 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					const wireElements = use(flightRoot);
 					const elements = AppElementsWire.decode(wireElements);
 					const metadata = AppElementsWire.readMetadata(elements);
-					const routeTree = createElement(ElementsContext.Provider, { value: elements }, createElement(Slot, { id: metadata.routeId }));
-					const stateKeyTree = createElement(BfcacheStateKeyMapContext.Provider, { value: createBfcacheSegmentStateKeyMap({
+					const bfcacheMaps = createInitialBfcacheMaps({
 						elements,
+						metadata,
 						pathname: ssrNavigationContext.pathname
-					}) }, routeTree);
-					return BfcacheIdMapContext ? createElement(BfcacheIdMapContext.Provider, { value: createInitialBfcacheIdMap(elements) }, stateKeyTree) : stateKeyTree;
+					});
+					const routeTree = createElement(ElementsContext.Provider, { value: elements }, createElement(Slot, { id: metadata.routeId }));
+					const stateKeyTree = createElement(BfcacheStateKeyMapContext.Provider, { value: bfcacheMaps.stateKeys }, routeTree);
+					return BfcacheIdMapContext ? createElement(BfcacheIdMapContext.Provider, { value: bfcacheMaps.bfcacheIds }, stateKeyTree) : stateKeyTree;
 				}
 				const flightRootElement = createElement(VinextFlightRoot);
 				const root = AppRouterContext ? createElement(AppRouterContext.Provider, { value: ssrAppRouterInstance }, flightRootElement) : flightRootElement;

package/dist/server/headers.d.ts

@@ -23,6 +23,10 @@ declare const VINEXT_TIMING_HEADER = "x-vinext-timing";
 declare const VINEXT_PRERENDER_SECRET_HEADER = "x-vinext-prerender-secret";
 /** URL-encoded JSON route params for build-time prerender renders. */
 declare const VINEXT_PRERENDER_ROUTE_PARAMS_HEADER = "x-vinext-prerender-route-params";
+/** Internal endpoint used to evaluate App Router generateStaticParams exports. */
+declare const VINEXT_PRERENDER_STATIC_PARAMS_PATH = "/__vinext/prerender/static-params";
+/** Internal endpoint used to evaluate Pages Router getStaticPaths exports. */
+declare const VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH = "/__vinext/prerender/pages-static-paths";
 /** TPR (Tailored Per-Request) revalidation interval in seconds. */
 declare const VINEXT_REVALIDATE_HEADER = "x-vinext-revalidate";
 /** Marker on cached ISR entries indicating RSC payload (value "1"). */
@@ -107,4 +111,4 @@ declare const INTERNAL_HEADERS: string[];
 /** Vinext-only internal headers stripped alongside Next.js protocol internals. */
 declare const VINEXT_INTERNAL_HEADERS: string[];
 //#endregion
-export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_STATIC_FILE_HEADER, VINEXT_TIMING_HEADER };
+export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_STATIC_PARAMS_PATH, VINEXT_REVALIDATE_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_STATIC_FILE_HEADER, VINEXT_TIMING_HEADER };

package/dist/server/headers.js

@@ -23,6 +23,10 @@ const VINEXT_TIMING_HEADER = "x-vinext-timing";
 const VINEXT_PRERENDER_SECRET_HEADER = "x-vinext-prerender-secret";
 /** URL-encoded JSON route params for build-time prerender renders. */
 const VINEXT_PRERENDER_ROUTE_PARAMS_HEADER = "x-vinext-prerender-route-params";
+/** Internal endpoint used to evaluate App Router generateStaticParams exports. */
+const VINEXT_PRERENDER_STATIC_PARAMS_PATH = "/__vinext/prerender/static-params";
+/** Internal endpoint used to evaluate Pages Router getStaticPaths exports. */
+const VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH = "/__vinext/prerender/pages-static-paths";
 /** TPR (Tailored Per-Request) revalidation interval in seconds. */
 const VINEXT_REVALIDATE_HEADER = "x-vinext-revalidate";
 /** Marker on cached ISR entries indicating RSC payload (value "1"). */
@@ -129,4 +133,4 @@ const INTERNAL_HEADERS = [
 /** Vinext-only internal headers stripped alongside Next.js protocol internals. */
 const VINEXT_INTERNAL_HEADERS = [VINEXT_PRERENDER_ROUTE_PARAMS_HEADER];
 //#endregion
-export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_STATIC_FILE_HEADER, VINEXT_TIMING_HEADER };
+export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_STATIC_PARAMS_PATH, VINEXT_REVALIDATE_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_STATIC_FILE_HEADER, VINEXT_TIMING_HEADER };

package/dist/server/metadata-route-response.d.ts

@@ -2,15 +2,15 @@ import { MetadataFileRoute } from "./metadata-routes.js";
 
 //#region src/server/metadata-route-response.d.ts
 type AppPageParams = Record<string, string | string[]>;
-type MakeThenableParams = (params: AppPageParams) => unknown;
+type MetadataRouteMakeThenableParams = (params: AppPageParams) => unknown;
 type MetadataRuntimeRoute = MetadataFileRoute & {
   fileDataBase64?: string;
 };
 type MetadataRouteRequestOptions = {
   metadataRoutes: readonly MetadataRuntimeRoute[];
   cleanPathname: string;
-  makeThenableParams: MakeThenableParams;
+  makeThenableParams: MetadataRouteMakeThenableParams;
 };
 declare function handleMetadataRouteRequest(options: MetadataRouteRequestOptions): Promise<Response | null>;
 //#endregion
-export { handleMetadataRouteRequest };
+export { MetadataRuntimeRoute, handleMetadataRouteRequest };

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

@@ -56,6 +56,7 @@ type ExecuteMiddlewareOptions = {
 type RunGeneratedMiddlewareOptions = ExecuteMiddlewareOptions & {
   ctx?: ExecutionContextLike;
 };
+declare function createMiddlewareMissingExportError(filePath: string | undefined, isProxy: boolean): Error;
 declare function resolveMiddlewareModuleHandler(mod: MiddlewareModule, options: {
   filePath?: string;
   isProxy: boolean;
@@ -63,4 +64,4 @@ declare function resolveMiddlewareModuleHandler(mod: MiddlewareModule, options:
 declare function executeMiddleware(options: ExecuteMiddlewareOptions): Promise<MiddlewareResult>;
 declare function runGeneratedMiddleware(options: RunGeneratedMiddlewareOptions): Promise<MiddlewareResult>;
 //#endregion
-export { MiddlewareModule, MiddlewareResult, executeMiddleware, resolveMiddlewareModuleHandler, runGeneratedMiddleware };
+export { MiddlewareModule, MiddlewareResult, createMiddlewareMissingExportError, executeMiddleware, resolveMiddlewareModuleHandler, runGeneratedMiddleware };

package/dist/server/middleware-runtime.js

@@ -9,6 +9,7 @@ import { normalizePath } from "./normalize-path.js";
 import { matchesMiddleware } from "./middleware-matcher.js";
 import { badRequestResponse, internalServerErrorResponse } from "./http-error-responses.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
+import path from "node:path";
 //#region src/server/middleware-runtime.ts
 function isMiddlewareHandler(value) {
 	return typeof value === "function";
@@ -16,19 +17,29 @@ function isMiddlewareHandler(value) {
 function isMiddlewareConfigExport(value) {
 	return !!value && typeof value === "object";
 }
-function middlewareFileLabel(isProxy) {
-	return isProxy ? "Proxy" : "Middleware";
-}
 function middlewareExpectedExport(isProxy) {
 	return isProxy ? "proxy" : "middleware";
 }
+function middlewareDisplayPath(filePath) {
+	const fileName = path.basename(filePath);
+	return path.basename(path.dirname(filePath)) === "src" ? `./src/${fileName}` : `./${fileName}`;
+}
+function createMiddlewareMissingExportError(filePath, isProxy) {
+	const expectedExport = middlewareExpectedExport(isProxy);
+	const displayPath = filePath ? middlewareDisplayPath(filePath) : void 0;
+	const resolvedPath = displayPath ? ` "${displayPath}"` : "";
+	const migrationReason = isProxy ? "- You are migrating from `middleware` to `proxy`, but haven't updated the exported function.\n" : "";
+	return /* @__PURE__ */ new Error(`The file${resolvedPath} must export a function, either as a default export or as a named "${expectedExport}" export.\nThis function is what Next.js runs for every request handled by this ${isProxy ? "proxy (previously called middleware)" : "middleware"}.\n\nWhy this happens:\n` + migrationReason + `- The file exists but doesn't export a function.
+- The export is not a function (e.g., an object or constant).
+- There's a syntax error preventing the export from being recognized.
+
+To fix it:
+- Ensure this file has either a default or "${expectedExport}" function export.\n\nLearn more: https://nextjs.org/docs/messages/middleware-to-proxy`);
+}
 function resolveMiddlewareModuleHandler(mod, options) {
 	const handler = options.isProxy ? mod.proxy ?? mod.default : mod.middleware ?? mod.default;
 	if (isMiddlewareHandler(handler)) return handler;
-	const fileLabel = middlewareFileLabel(options.isProxy);
-	const expectedExport = middlewareExpectedExport(options.isProxy);
-	const fileSuffix = options.filePath ? ` "${options.filePath}"` : "";
-	throw new Error(`The ${fileLabel} file${fileSuffix} must export a function named \`${expectedExport}\` or a \`default\` function.`);
+	throw createMiddlewareMissingExportError(options.filePath, options.isProxy);
 }
 function middlewareMatcher(mod) {
 	const config = mod.config;
@@ -226,4 +237,4 @@ async function runGeneratedMiddleware(options) {
 	return options.ctx ? runWithExecutionContext(options.ctx, run) : run();
 }
 //#endregion
-export { executeMiddleware, resolveMiddlewareModuleHandler, runGeneratedMiddleware };
+export { createMiddlewareMissingExportError, executeMiddleware, resolveMiddlewareModuleHandler, runGeneratedMiddleware };