vinext 0.1.8 → 0.2.0

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

@@ -1,7 +1,8 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { ACTION_REVALIDATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
+import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "../utils/protocol-headers.js";
+import { ACTION_REVALIDATED_HEADER } from "./headers.js";
 import { isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
@@ -10,18 +11,19 @@ import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.
 import { mergeRewriteQuery } from "../utils/query.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.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 { parseNextHttpErrorDigest } from "./next-error-digest.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 { 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 { flattenErrorCauses } from "../utils/error-cause.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
 import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
@@ -53,8 +55,8 @@ function createMissingServerActionResponse(options, actionId) {
 	options.clearRequestContext();
 	return createServerActionNotFoundResponse();
 }
-function redirectDestinationWithBasePath(destination, basePath) {
-	if (!basePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
+function redirectDestinationWithBasePath(destination, basePath, hadBasePath) {
+	if (!basePath || !hadBasePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
 	return basePath + destination;
 }
 async function applyRewrite(options, cleanPathname) {
@@ -111,15 +113,22 @@ function requestWithoutRscSuffix(request) {
 	url.pathname = pathname;
 	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
 }
-async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest) {
+async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, isMiddlewareDataRequest, pagesDataRequest) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
 		const originBlock = options.validateDevRequestOrigin?.(request);
 		if (originBlock) return originBlock;
 	}
-	const normalized = normalizeRscRequest(request, options.basePath);
+	const canHandleOutsideBasePath = Boolean(options.runMiddleware) || [
+		...options.configRedirects,
+		...options.configRewrites.beforeFiles,
+		...options.configRewrites.afterFiles,
+		...options.configRewrites.fallback,
+		...options.configHeaders
+	].some((rule) => rule.basePath === false);
+	const normalized = normalizeRscRequest(request, options.basePath, canHandleOutsideBasePath);
 	if (normalized instanceof Response) return normalized;
-	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest } = normalized;
+	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest, hadBasePath } = normalized;
 	let { pathname, cleanPathname } = normalized;
 	let resolvedUrl = cleanPathname + url.search;
 	const originalResolvedUrl = resolvedUrl;
@@ -127,7 +136,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const canonicalPathname = cleanPathname;
 	const basePathState = {
 		basePath: options.basePath,
-		hadBasePath: true
+		hadBasePath
 	};
 	if (pathname === "/__vinext/prerender/static-params" || pathname === "/__vinext/prerender/pages-static-paths") {
 		const { handleAppPrerenderEndpoint } = await import("./app-prerender-endpoints.js");
@@ -142,17 +151,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		});
 		if (prerenderEndpointResponse) return prerenderEndpointResponse;
 	}
-	const trailingSlashRedirect = normalizeTrailingSlash(pathname, options.basePath, options.trailingSlash, url.search);
+	const trailingSlashRedirect = normalizeTrailingSlash(pathname, hadBasePath ? options.basePath : "", options.trailingSlash, url.search);
 	if (trailingSlashRedirect) return trailingSlashRedirect;
 	const matchPathname = (p) => normalizeDefaultLocalePathname(p, options.i18nConfig, { hostname: url.hostname });
 	const redirect = matchRedirect(matchPathname(stripRscSuffix(pathname)), options.configRedirects, preMiddlewareRequestContext, basePathState);
 	if (redirect) {
-		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath));
+		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath, hadBasePath));
 		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : preserveRedirectDestinationQuery(destination, url.search);
-		if (isDataRequest) return new Response(null, {
-			status: 200,
-			headers: { "x-nextjs-redirect": location }
-		});
 		return new Response(null, {
 			status: redirect.permanent ? 308 : 307,
 			headers: { Location: location }
@@ -171,11 +176,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		status: null
 	};
 	let didMiddlewareRewrite = false;
+	let didMiddlewareRewritePathname = false;
 	if (options.runMiddleware) {
 		const middlewareResult = await options.runMiddleware({
 			cleanPathname,
 			context: middlewareContext,
-			isDataRequest,
+			hadBasePath,
+			isDataRequest: isMiddlewareDataRequest,
 			request: userlandRequest
 		});
 		if (middlewareResult.kind === "response") return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
@@ -185,12 +192,14 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			requestContext: preMiddlewareRequestContext
 		});
 		cleanPathname = middlewareResult.cleanPathname;
-		didMiddlewareRewrite = cleanPathname !== normalized.cleanPathname;
+		didMiddlewareRewrite = middlewareResult.rewritten;
+		didMiddlewareRewritePathname = cleanPathname !== normalized.cleanPathname;
 		if (middlewareResult.search !== null) url.search = middlewareResult.search;
 		resolvedUrl = cleanPathname + url.search;
 	}
 	const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareContext.headers);
 	const postMiddlewareRequestContext = buildPostMwRequestContext(userlandRequest);
+	let filesystemRouteEligible = hadBasePath || didMiddlewareRewrite;
 	for (const rewrite of options.configRewrites.beforeFiles) {
 		const beforeFilesRewrite = await applyRewrite({
 			basePathState,
@@ -203,14 +212,15 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (beforeFilesRewrite) {
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, beforeFilesRewrite);
 			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			filesystemRouteEligible = true;
 		}
 	}
-	if (isImageOptimizationPath(cleanPathname)) {
+	if (filesystemRouteEligible && isImageOptimizationPath(cleanPathname)) {
 		const imageRedirect = resolveDevImageRedirect(url, [...options.imageConfig?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...options.imageConfig?.imageSizes ?? DEFAULT_IMAGE_SIZES], options.imageConfig?.qualities, { isDev: options.isDev });
 		if (!imageRedirect) return new Response("Invalid image optimization parameters", { status: 400 });
 		return Response.redirect(new URL(imageRedirect, url.origin).href, 302);
 	}
-	if (options.handleMetadataRouteRequest) {
+	if (filesystemRouteEligible && options.handleMetadataRouteRequest) {
 		const metadataRouteResponse = await options.handleMetadataRouteRequest(cleanPathname);
 		if (metadataRouteResponse) {
 			applyConfigHeadersToResponse(metadataRouteResponse.headers, {
@@ -223,13 +233,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
 		}
 	}
-	const publicFileResponse = resolvePublicFileRoute({
+	const publicFileResponse = filesystemRouteEligible ? resolvePublicFileRoute({
 		cleanPathname,
 		middlewareContext,
 		pathname,
 		publicFiles: options.publicFiles,
 		request
-	});
+	}) : null;
 	if (publicFileResponse) {
 		options.clearRequestContext();
 		return publicFileResponse;
@@ -243,13 +253,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams(),
 		params: {}
 	});
-	const preActionMatch = options.matchRoute(cleanPathname);
+	const preActionMatch = filesystemRouteEligible ? options.matchRoute(cleanPathname) : null;
 	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 isPostRequest = request.method.toUpperCase() === "POST";
 	let progressiveActionResult = null;
-	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
+	if (filesystemRouteEligible && isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
 		if (options.handleProgressiveActionRequest) progressiveActionResult = await options.handleProgressiveActionRequest({
 			actionId,
 			cleanPathname,
@@ -266,7 +276,11 @@ 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 && options.handleServerActionRequest ? await options.handleServerActionRequest({
+	const actionErrorDigest = actionError && typeof actionError === "object" && "digest" in actionError ? String(actionError.digest) : null;
+	const actionHttpFallbackStatus = actionErrorDigest ? parseNextHttpErrorDigest(actionErrorDigest)?.status ?? null : null;
+	const normalizedProgressiveActionError = actionHttpFallbackStatus === null || actionHttpFallbackStatus === 404 ? actionError : { digest: "NEXT_NOT_FOUND" };
+	if (actionFailed && middlewareContext.status === null && actionHttpFallbackStatus === null) middlewareContext.status = 500;
+	const serverActionResponse = filesystemRouteEligible && isPostRequest && actionId && options.handleServerActionRequest ? await options.handleServerActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -278,12 +292,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams()
 	}) : null;
 	if (serverActionResponse) return serverActionResponse;
-	if (isPostRequest && actionId && !options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
+	if (filesystemRouteEligible && isPostRequest && actionId && !options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
 	let match = preActionMatch;
 	const renderPagesForMatchKind = async (matchKind) => {
+		if (!filesystemRouteEligible) return null;
 		const response = match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
 			appRouteMatch: match ?? null,
-			allowRscDocumentFallback: didMiddlewareRewrite,
+			allowRscDocumentFallback: didMiddlewareRewritePathname,
 			isDataRequest,
 			isRscRequest,
 			matchKind,
@@ -319,6 +334,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!afterFilesRewrite) continue;
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, afterFilesRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		filesystemRouteEligible = true;
 		match = options.matchRoute(cleanPathname);
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -349,6 +365,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!fallbackRewrite) continue;
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		filesystemRouteEligible = true;
 		match = options.matchRoute(cleanPathname);
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -362,8 +379,23 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		}
 		if (match) break;
 	}
+	if (!filesystemRouteEligible) {
+		options.clearRequestContext();
+		const headers = new Headers();
+		mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+		return notFoundResponse({ headers });
+	}
 	if (pagesDataRequest) {
 		options.clearRequestContext();
+		if (options.runMiddleware && (middlewareContext.status === null || middlewareContext.status === 200 || middlewareContext.status === 404)) {
+			const response = buildNextDataNotFoundResponse();
+			const headers = new Headers(response.headers);
+			headers.set("x-nextjs-matched-path", matchPathname(canonicalPathname));
+			return new Response("{}", {
+				status: 200,
+				headers
+			});
+		}
 		return buildNextDataNotFoundResponse();
 	}
 	if (!match) {
@@ -425,7 +457,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		cleanPathname,
 		displayPathname: canonicalPathname,
 		formState,
-		actionError,
+		actionError: normalizedProgressiveActionError,
 		actionFailed,
 		handlerStart,
 		interceptionContext: interceptionContextHeader,
@@ -489,14 +521,13 @@ function createAppRscHandler(options) {
 		options.registerCacheAdapters();
 		await options.ensureInstrumentation?.();
 		const mwCtx = rawRequest.headers.get(VINEXT_MW_CTX_HEADER);
-		const hasDataRequestHeader = rawRequest.headers.get("x-nextjs-data") === "1";
 		const pagesDataUrl = new URL(rawRequest.url);
 		const pagesDataInScope = !options.basePath || hasBasePath(pagesDataUrl.pathname, options.basePath);
 		if (pagesDataInScope) pagesDataUrl.pathname = stripBasePath(pagesDataUrl.pathname, options.basePath);
 		const pagesDataCandidate = pagesDataInScope ? cloneRequestWithUrl(rawRequest, pagesDataUrl.toString()) : null;
 		const pagesDataNormalization = options.renderPagesFallback && pagesDataCandidate ? normalizePagesDataRequest(pagesDataCandidate, options.buildId) : null;
 		if (pagesDataNormalization?.notFoundResponse) return pagesDataNormalization.notFoundResponse;
-		const isDataRequest = hasDataRequestHeader || pagesDataNormalization?.isDataReq === true;
+		const isPagesDataRequest = pagesDataNormalization?.isDataReq === true;
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(rawRequest);
 		const filteredHeaders = filterInternalHeaders(rawRequest.headers);
 		if (mwCtx !== null) filteredHeaders.set(VINEXT_MW_CTX_HEADER, mwCtx);
@@ -520,7 +551,7 @@ function createAppRscHandler(options) {
 			const preMiddlewareRequestContext = requestContextFromRequest(request);
 			let response;
 			try {
-				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest);
+				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isPagesDataRequest, isPagesDataRequest, pagesDataRequest);
 			} catch (error) {
 				if (process.env.NODE_ENV !== "production") flattenErrorCauses(error);
 				throw error;

package/dist/server/app-rsc-request-normalization.d.ts

@@ -11,7 +11,8 @@ type NormalizedRscRequest = {
   interceptionContextHeader: string | null; /** Normalized x-vinext-mounted-slots header (deduplicated, sorted). null when absent or blank. */
   mountedSlotsHeader: string | null; /** Semantic RSC payload mode. HTML requests always normalize to "navigation". */
   renderMode: AppRscRenderMode; /** Parsed ClientReuseManifest hint. Verification and skip authorization happen later. */
-  clientReuseManifest: ClientReuseManifestParseResult;
+  clientReuseManifest: ClientReuseManifestParseResult; /** Whether the incoming pathname included the configured basePath. */
+  hadBasePath: boolean;
 };
 /**
  * Normalize an App Router RSC request.
@@ -43,6 +44,6 @@ type NormalizedRscRequest = {
  * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
  *          or a NormalizedRscRequest for valid requests.
  */
-declare function normalizeRscRequest(request: Request, basePath: string): Response | NormalizedRscRequest;
+declare function normalizeRscRequest(request: Request, basePath: string, allowOutsideBasePath?: boolean): Response | NormalizedRscRequest;
 //#endregion
 export { NormalizedRscRequest, normalizeMountedSlotsHeader, normalizeRscRequest };

package/dist/server/app-rsc-request-normalization.js

@@ -40,7 +40,7 @@ import { normalizeInterceptionContextHeader } from "./app-interception-context-h
 * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
 *          or a NormalizedRscRequest for valid requests.
 */
-function normalizeRscRequest(request, basePath) {
+function normalizeRscRequest(request, basePath, allowOutsideBasePath = false) {
 	const url = new URL(request.url);
 	const protoGuard = guardProtocolRelativeUrl(url.pathname);
 	if (protoGuard) return protoGuard;
@@ -51,9 +51,11 @@ function normalizeRscRequest(request, basePath) {
 		return badRequestResponse();
 	}
 	let pathname = normalizePath(decoded);
+	let hadBasePath = true;
 	if (basePath) {
-		if (!hasBasePath(pathname, basePath) && !pathname.startsWith("/__vinext/")) return notFoundResponse();
-		pathname = stripBasePath(pathname, basePath);
+		hadBasePath = hasBasePath(pathname, basePath);
+		if (!hadBasePath && !pathname.startsWith("/__vinext/") && !allowOutsideBasePath) return notFoundResponse();
+		if (hadBasePath) pathname = stripBasePath(pathname, basePath);
 	}
 	const isRscRequest = pathname.endsWith(".rsc") || request.headers.get("RSC") === "1" && url.searchParams.has("_rsc");
 	const cleanPathname = stripRscSuffix(pathname);
@@ -62,6 +64,7 @@ function normalizeRscRequest(request, basePath) {
 	const renderMode = isRscRequest ? parseAppRscRenderMode(request.headers.get(VINEXT_RSC_RENDER_MODE_HEADER)) : APP_RSC_RENDER_MODE_NAVIGATION;
 	return {
 		clientReuseManifest: isRscRequest ? parseClientReuseManifestHeader(request.headers.get(VINEXT_CLIENT_REUSE_MANIFEST_HEADER)) : { kind: "absent" },
+		hadBasePath,
 		url,
 		pathname,
 		cleanPathname,

package/dist/server/app-segment-config.d.ts

@@ -6,6 +6,7 @@ type AppRouteSegmentConfigModule = {
   dynamic?: unknown;
   dynamicParams?: unknown;
   fetchCache?: unknown;
+  generateStaticParams?: unknown;
   revalidate?: unknown;
   runtime?: unknown;
   unstable_dynamicStaleTime?: unknown;
@@ -18,11 +19,21 @@ type EffectiveAppPageSegmentConfig = {
   revalidateSeconds: number | null;
   runtime?: "edge" | "experimental-edge" | "nodejs";
 };
+type ParallelAppPageSegmentConfigBranch = {
+  configLayouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
+  layout?: AppRouteSegmentConfigModule | null;
+  page?: AppRouteSegmentConfigModule | null;
+  routeSegments?: readonly string[] | null;
+};
 type ResolveAppPageSegmentConfigOptions = {
   layouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
+  layoutTreePositions?: readonly number[];
   page?: AppRouteSegmentConfigModule | null;
+  parallelBranches?: readonly (ParallelAppPageSegmentConfigBranch | null | undefined)[];
   parallelPages?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
   parallelSegments?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
+  routeSegments?: readonly string[];
 };
 /**
  * Resolve the route segment config that applies to an App page route.

package/dist/server/app-segment-config.js

@@ -37,6 +37,65 @@ function resolveDynamicStaleTimeSeconds(current, value) {
 	if (typeof value !== "number" || !Number.isInteger(value) || value < 0) return current;
 	return current === void 0 ? value : Math.min(current, value);
 }
+function isDynamicSegment(segment) {
+	return segment.startsWith("[") && segment.endsWith("]");
+}
+function getParallelSegments(options) {
+	if (!options.parallelBranches) return options.parallelSegments ?? [];
+	return options.parallelBranches.flatMap((branch) => branch ? [
+		branch.layout,
+		...branch.configLayouts ?? [],
+		branch.page
+	] : []);
+}
+function resolveDynamicParamsConfig(options) {
+	const parallelSegments = getParallelSegments(options);
+	const segments = [
+		...options.layouts ?? [],
+		options.page,
+		...parallelSegments
+	];
+	let dynamicParamsConfig;
+	for (const segment of segments) if (segment?.dynamicParams === false) dynamicParamsConfig = false;
+	else if (segment?.dynamicParams === true && dynamicParamsConfig !== false) dynamicParamsConfig = true;
+	if (dynamicParamsConfig !== false || !options.routeSegments) return dynamicParamsConfig;
+	let lastDynamicPosition = -1;
+	for (let index = options.routeSegments.length - 1; index >= 0; index--) if (isDynamicSegment(options.routeSegments[index])) {
+		lastDynamicPosition = index;
+		break;
+	}
+	if (lastDynamicPosition < 0) return dynamicParamsConfig;
+	const layouts = options.layouts ?? [];
+	const layoutPositions = options.layoutTreePositions ?? [];
+	let lastDynamicSegmentIsStaticOnly = false;
+	let lastDynamicSegmentHasStaticParams = false;
+	layouts.forEach((layout, index) => {
+		if ((layoutPositions[index] ?? 0) - 1 !== lastDynamicPosition) return;
+		if (layout?.dynamicParams === false) lastDynamicSegmentIsStaticOnly = true;
+		if (typeof layout?.generateStaticParams === "function") lastDynamicSegmentHasStaticParams = true;
+	});
+	if (options.page?.dynamicParams === false) lastDynamicSegmentIsStaticOnly = true;
+	if (typeof options.page?.generateStaticParams === "function") lastDynamicSegmentHasStaticParams = true;
+	for (const branch of options.parallelBranches ?? []) {
+		if (!branch) continue;
+		const branchStartPosition = options.routeSegments.length - (branch.routeSegments?.length ?? 0);
+		const checkSegment = (segment, ownerPosition) => {
+			if (ownerPosition !== lastDynamicPosition) return;
+			if (segment?.dynamicParams === false) lastDynamicSegmentIsStaticOnly = true;
+			if (typeof segment?.generateStaticParams === "function") lastDynamicSegmentHasStaticParams = true;
+		};
+		checkSegment(branch.layout, branchStartPosition - 1);
+		branch.configLayouts?.forEach((layout, index) => {
+			checkSegment(layout, branchStartPosition + (branch.configLayoutTreePositions?.[index] ?? 0) - 1);
+		});
+		checkSegment(branch.page, branchStartPosition + (branch.routeSegments?.length ?? 0) - 1);
+	}
+	if (!options.parallelBranches) for (const segment of parallelSegments) {
+		if (segment?.dynamicParams === false) lastDynamicSegmentIsStaticOnly = true;
+		if (typeof segment?.generateStaticParams === "function") lastDynamicSegmentHasStaticParams = true;
+	}
+	return lastDynamicSegmentIsStaticOnly || lastDynamicSegmentHasStaticParams ? false : void 0;
+}
 function isCacheFetchCacheMode(value) {
 	return value === "default-cache" || value === "force-cache" || value === "only-cache";
 }
@@ -53,7 +112,9 @@ function describeFetchCacheConflict(value) {
 */
 function resolveAppPageSegmentConfig(options) {
 	const segments = [...options.layouts ?? [], options.page];
+	const parallelSegments = getParallelSegments(options);
 	const config = { revalidateSeconds: null };
+	config.dynamicParamsConfig = resolveDynamicParamsConfig(options);
 	let hasForceCache = false;
 	let hasForceNoStore = false;
 	let hasOnlyCache = false;
@@ -67,8 +128,6 @@ function resolveAppPageSegmentConfig(options) {
 			config.dynamicConfig = hasForceDynamic ? "force-dynamic" : segment.dynamic;
 		}
 		if (isRouteSegmentRuntime(segment.runtime)) config.runtime = segment.runtime;
-		if (segment.dynamicParams === false) config.dynamicParamsConfig = false;
-		else if (segment.dynamicParams === true && config.dynamicParamsConfig !== false) config.dynamicParamsConfig = true;
 		if (isRouteSegmentFetchCache(segment.fetchCache)) {
 			const fetchCache = segment.fetchCache;
 			if (hasParentDefaultNoStore && (fetchCache === "auto" || isCacheFetchCacheMode(fetchCache))) throw new Error(describeFetchCacheConflict(fetchCache));
@@ -86,14 +145,12 @@ function resolveAppPageSegmentConfig(options) {
 		}
 		config.revalidateSeconds = resolveRevalidateSeconds(config.revalidateSeconds, segment.revalidate);
 	}
-	for (const segment of options.parallelSegments ?? []) {
+	for (const segment of parallelSegments) {
 		if (!segment) continue;
 		if (segment.dynamic === "force-dynamic") {
 			hasForceDynamic = true;
 			config.dynamicConfig = "force-dynamic";
 		} else if (config.dynamicConfig === void 0 && isRouteSegmentDynamic(segment.dynamic)) config.dynamicConfig = segment.dynamic;
-		if (segment.dynamicParams === false) config.dynamicParamsConfig = false;
-		else if (segment.dynamicParams === true && config.dynamicParamsConfig === void 0) config.dynamicParamsConfig = true;
 		if (config.runtime === void 0 && isRouteSegmentRuntime(segment.runtime)) config.runtime = segment.runtime;
 		if (isRouteSegmentFetchCache(segment.fetchCache)) {
 			const fetchCache = segment.fetchCache;
@@ -120,7 +177,6 @@ function resolveAppPageSegmentConfig(options) {
 	if (config.fetchCache === void 0) {
 		if (config.dynamicConfig === "error") config.fetchCache = "only-cache";
 	}
-	if (config.dynamicParamsConfig === void 0 && (config.dynamicConfig === "error" || config.dynamicConfig === "force-static")) config.dynamicParamsConfig = false;
 	return config;
 }
 function resolveAppPageFetchCacheMode(options) {

package/dist/server/app-server-action-execution.d.ts

@@ -29,6 +29,7 @@ type AppServerActionReturnValue = {
 type AppServerActionRoute = {
   page?: unknown;
   pattern: string;
+  rootParamNames?: readonly string[];
   routeHandler?: unknown;
   routeSegments?: readonly string[];
   params?: readonly string[] | null;