@qzsy/vinext 0.1.11 → 0.1.80

package/dist/server/app-router-image-optimization.d.ts

@@ -0,0 +1,37 @@
+import { ImageConfig } from "./image-optimization.js";
+
+//#region src/server/app-router-image-optimization.d.ts
+type AssetFetcher = {
+  fetch(request: Request): Promise<Response> | Response;
+};
+type ImagesBinding = {
+  input(stream: ReadableStream): {
+    transform(options: Record<string, unknown>): {
+      output(options: {
+        format: string;
+        quality: number;
+      }): Promise<{
+        response(): Response;
+      }>;
+    };
+  };
+};
+type AppRouterImageOptimizationEnv = {
+  ASSETS?: AssetFetcher;
+  IMAGES?: ImagesBinding;
+};
+/** Build image security/size config from Vite `define` env vars baked at build time. */
+declare function createImageConfigFromEnv(): ImageConfig;
+/**
+ * Serve `/_next/image` from the Worker ASSETS binding when available.
+ *
+ * The default App Router worker entry delegates here before the RSC handler so
+ * production requests do not fall through to the dev-style redirect path (which
+ * can emit http:// Locations behind TLS-terminating proxies).
+ */
+declare function handleAppRouterImageOptimizationRequest(request: Request, options: {
+  basePath: string;
+  env: AppRouterImageOptimizationEnv;
+}): Promise<Response | null>;
+//#endregion
+export { AppRouterImageOptimizationEnv, createImageConfigFromEnv, handleAppRouterImageOptimizationRequest };

package/dist/server/app-router-image-optimization.js

@@ -0,0 +1,40 @@
+import { stripBasePath } from "../utils/base-path.js";
+import { cloneRequestWithUrl } from "./request-pipeline.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
+//#region src/server/app-router-image-optimization.ts
+/** Build image security/size config from Vite `define` env vars baked at build time. */
+function createImageConfigFromEnv() {
+	return {
+		deviceSizes: JSON.parse(process.env.__VINEXT_IMAGE_DEVICE_SIZES ?? JSON.stringify(DEFAULT_DEVICE_SIZES)),
+		imageSizes: JSON.parse(process.env.__VINEXT_IMAGE_SIZES ?? JSON.stringify(DEFAULT_IMAGE_SIZES)),
+		qualities: JSON.parse(process.env.__VINEXT_IMAGE_QUALITIES ?? "null") ?? void 0,
+		dangerouslyAllowSVG: process.env.__VINEXT_IMAGE_DANGEROUSLY_ALLOW_SVG === "true",
+		dangerouslyAllowLocalIP: process.env.__VINEXT_IMAGE_DANGEROUSLY_ALLOW_LOCAL_IP === "true"
+	};
+}
+/**
+* Serve `/_next/image` from the Worker ASSETS binding when available.
+*
+* The default App Router worker entry delegates here before the RSC handler so
+* production requests do not fall through to the dev-style redirect path (which
+* can emit http:// Locations behind TLS-terminating proxies).
+*/
+async function handleAppRouterImageOptimizationRequest(request, options) {
+	const url = new URL(request.url);
+	const strippedPathname = stripBasePath(url.pathname, options.basePath);
+	if (!isImageOptimizationPath(strippedPathname) || !options.env.ASSETS) return null;
+	const imageRequest = strippedPathname === url.pathname ? request : cloneRequestWithUrl(request, new URL(`${strippedPathname}${url.search}`, url).href);
+	const imageConfig = createImageConfigFromEnv();
+	const allowedWidths = [...imageConfig.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...imageConfig.imageSizes ?? DEFAULT_IMAGE_SIZES];
+	const handlers = { fetchAsset: (path) => Promise.resolve(options.env.ASSETS.fetch(new Request(new URL(path, request.url)))) };
+	const imagesBinding = options.env.IMAGES;
+	if (imagesBinding) handlers.transformImage = async (body, { width, format, quality }) => {
+		return (await imagesBinding.input(body).transform(width > 0 ? { width } : {}).output({
+			format,
+			quality
+		})).response();
+	};
+	return handleImageOptimization(imageRequest, handlers, allowedWidths, imageConfig);
+}
+//#endregion
+export { createImageConfigFromEnv, handleAppRouterImageOptimizationRequest };

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

@@ -53,7 +53,13 @@ function createRscOnErrorHandler(options) {
 		}
 		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));
+		if (error) {
+			const digest = errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
+			if (error instanceof Error) try {
+				Object.assign(error, { digest });
+			} catch {}
+			return digest;
+		}
 	};
 }
 //#endregion

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, bufferRequestBodyForHeaderClone, 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 { 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";
@@ -111,7 +113,7 @@ 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);
@@ -149,10 +151,6 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (redirect) {
 		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath));
 		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 }
@@ -175,7 +173,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		const middlewareResult = await options.runMiddleware({
 			cleanPathname,
 			context: middlewareContext,
-			isDataRequest,
+			isDataRequest: isMiddlewareDataRequest,
 			request: userlandRequest
 		});
 		if (middlewareResult.kind === "response") return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
@@ -208,7 +206,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (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);
+		return new Response(null, {
+			status: 302,
+			headers: { Location: imageRedirect }
+		});
 	}
 	if (options.handleMetadataRouteRequest) {
 		const metadataRouteResponse = await options.handleMetadataRouteRequest(cleanPathname);
@@ -266,6 +267,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const failedProgressiveActionResult = progressiveActionFormState && "actionError" in progressiveActionFormState ? progressiveActionFormState : null;
 	const actionFailed = failedProgressiveActionResult !== null;
 	const actionError = failedProgressiveActionResult?.actionError;
+	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 = isPostRequest && actionId && options.handleServerActionRequest ? await options.handleServerActionRequest({
 		actionId,
 		cleanPathname,
@@ -364,6 +369,15 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}
 	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 +439,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		cleanPathname,
 		displayPathname: canonicalPathname,
 		formState,
-		actionError,
+		actionError: normalizedProgressiveActionError,
 		actionFailed,
 		handlerStart,
 		interceptionContext: interceptionContextHeader,
@@ -490,14 +504,13 @@ function createAppRscHandler(options) {
 		await options.ensureInstrumentation?.();
 		rawRequest = await bufferRequestBodyForHeaderClone(rawRequest);
 		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);
@@ -521,7 +534,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-route-matching.d.ts

@@ -31,6 +31,8 @@ type AppRscInterceptForMatching = {
   sourceMatchPattern?: string;
   sourcePageSegments?: readonly string[];
   interceptLayouts: readonly unknown[];
+  interceptLayoutSegments?: readonly (readonly string[])[];
+  interceptBranchSegments?: readonly string[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
@@ -46,6 +48,8 @@ type AppRscSiblingInterceptForMatching = {
   sourcePageSegments?: readonly string[];
   slotId: string | null;
   interceptLayouts: readonly unknown[];
+  interceptLayoutSegments?: readonly (readonly string[])[];
+  interceptBranchSegments?: readonly string[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
@@ -59,6 +63,7 @@ type AppRscRouteForMatching = {
 };
 type AppRscInterceptMatch = AppRscInterceptLookupEntry & {
   matchedParams: AppRscRouteParams;
+  sourceMatchedParams: AppRscRouteParams;
 };
 type AppRscInterceptLoadState = {
   page: unknown;
@@ -74,6 +79,8 @@ type AppRscInterceptLookupEntry = {
   sourceMatchPatternParts: string[] | null;
   sourcePageSegments: readonly string[] | null;
   interceptLayouts: readonly unknown[];
+  interceptLayoutSegments?: readonly (readonly string[])[];
+  interceptBranchSegments?: readonly string[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;

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

@@ -36,12 +36,13 @@ function createAppRscRouteMatcher(routes) {
 				const sourceRoute = routes[concreteSourceRouteIndex];
 				const matchedSourceParams = matchedSourceRoute && entry.sourceMatchPatternParts !== null ? matchedSourceRoute.params : sourceRoute ? matchAppRscRoutePattern(sourceParts, sourceRoute.patternParts) : null;
 				if (matchedSourceParams === null && entry.sourceMatchPatternParts === null) continue;
-				const sourceParams = matchedSourceParams ?? createRouteParams();
+				const sourceParams = matchedSourceParams && entry.sourceMatchPatternParts !== null ? pickPatternParams(matchedSourceParams, entry.sourceMatchPatternParts) : matchedSourceParams ?? createRouteParams();
 				return {
 					...entry,
 					page: entry.__loadState.page,
 					sourceRouteIndex: concreteSourceRouteIndex,
-					matchedParams: mergeMatchedParams(sourceParams, params)
+					matchedParams: mergeMatchedParams(sourceParams, params),
+					sourceMatchedParams: matchedSourceParams ?? createRouteParams()
 				};
 			}
 			return null;
@@ -64,6 +65,24 @@ function matchInterceptSource(sourceParts, entry) {
 	if (patternParts.length === 0) return true;
 	return matchRoutePatternPrefix(sourceParts, patternParts);
 }
+function interceptSegmentPrecedence(segment) {
+	if (!segment.startsWith(":")) return 0;
+	if (segment.endsWith("*")) return 3;
+	if (segment.endsWith("+")) return 2;
+	return 1;
+}
+function compareInterceptTargetPatterns(a, b) {
+	const sharedLength = Math.min(a.targetPatternParts.length, b.targetPatternParts.length);
+	for (let index = 0; index < sharedLength; index++) {
+		const aSegment = a.targetPatternParts[index];
+		const bSegment = b.targetPatternParts[index];
+		const precedence = interceptSegmentPrecedence(aSegment) - interceptSegmentPrecedence(bSegment);
+		if (precedence !== 0) return precedence;
+		if (aSegment !== bSegment) return aSegment.localeCompare(bSegment);
+	}
+	const lengthDifference = a.targetPatternParts.length - b.targetPatternParts.length;
+	return lengthDifference !== 0 ? lengthDifference : a.targetPattern.localeCompare(b.targetPattern);
+}
 function createInterceptLookup(routes) {
 	const patternToIndex = new Map(routes.map((r, i) => [r.pattern, i]));
 	const interceptLookup = [];
@@ -85,6 +104,8 @@ function createInterceptLookup(routes) {
 					sourceMatchPatternParts,
 					sourcePageSegments: intercept.sourcePageSegments ?? null,
 					interceptLayouts: intercept.interceptLayouts,
+					interceptLayoutSegments: intercept.interceptLayoutSegments,
+					interceptBranchSegments: intercept.interceptBranchSegments,
 					__loadInterceptLayouts: intercept.__loadInterceptLayouts,
 					page: intercept.page,
 					__pageLoader: intercept.__pageLoader,
@@ -110,6 +131,8 @@ function createInterceptLookup(routes) {
 				sourceMatchPatternParts,
 				sourcePageSegments: intercept.sourcePageSegments ?? null,
 				interceptLayouts: intercept.interceptLayouts,
+				interceptLayoutSegments: intercept.interceptLayoutSegments,
+				interceptBranchSegments: intercept.interceptBranchSegments,
 				__loadInterceptLayouts: intercept.__loadInterceptLayouts,
 				page: intercept.page,
 				__pageLoader: intercept.__pageLoader,
@@ -122,7 +145,7 @@ function createInterceptLookup(routes) {
 			});
 		}
 	}
-	return interceptLookup;
+	return interceptLookup.sort(compareInterceptTargetPatterns);
 }
 function matchAppRscRoutePattern(urlParts, patternParts) {
 	return matchRoutePattern(urlParts, patternParts);
@@ -130,5 +153,15 @@ function matchAppRscRoutePattern(urlParts, patternParts) {
 function mergeMatchedParams(sourceParams, targetParams) {
 	return Object.assign(createRouteParams(), sourceParams, targetParams);
 }
+function pickPatternParams(params, patternParts) {
+	const picked = createRouteParams();
+	for (const patternPart of patternParts) {
+		if (!patternPart.startsWith(":")) continue;
+		const paramName = patternPart.endsWith("+") || patternPart.endsWith("*") ? patternPart.slice(1, -1) : patternPart.slice(1);
+		const value = params[paramName];
+		if (value !== void 0) picked[paramName] = value;
+	}
+	return picked;
+}
 //#endregion
 export { SIBLING_PAGE_INTERCEPT_SLOT_KEY, createAppRscRouteMatcher, matchAppRscRoutePattern };

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,10 +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,18 +112,22 @@ 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;
 	let hasOnlyNoStore = false;
 	let hasParentDefaultNoStore = false;
+	let hasForceDynamic = false;
 	for (const segment of segments) {
 		if (!segment) continue;
-		if (isRouteSegmentDynamic(segment.dynamic)) config.dynamicConfig = segment.dynamic;
+		if (isRouteSegmentDynamic(segment.dynamic)) {
+			if (segment.dynamic === "force-dynamic") hasForceDynamic = true;
+			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));
@@ -72,7 +135,7 @@ function resolveAppPageSegmentConfig(options) {
 			if (fetchCache === "force-no-store") hasForceNoStore = true;
 			if (fetchCache === "only-cache") hasOnlyCache = true;
 			if (fetchCache === "only-no-store") hasOnlyNoStore = true;
-			if ((hasForceCache || hasOnlyCache) && (hasForceNoStore || hasOnlyNoStore)) throw new Error(describeFetchCacheConflict(fetchCache));
+			if (hasForceCache && hasForceNoStore || !hasForceCache && !hasForceNoStore && hasOnlyCache && hasOnlyNoStore) throw new Error(describeFetchCacheConflict(fetchCache));
 			if (fetchCache === "default-no-store") hasParentDefaultNoStore = true;
 			if (hasForceCache) config.fetchCache = "force-cache";
 			else if (hasForceNoStore) config.fetchCache = "force-no-store";
@@ -82,6 +145,30 @@ function resolveAppPageSegmentConfig(options) {
 		}
 		config.revalidateSeconds = resolveRevalidateSeconds(config.revalidateSeconds, segment.revalidate);
 	}
+	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 (config.runtime === void 0 && isRouteSegmentRuntime(segment.runtime)) config.runtime = segment.runtime;
+		if (isRouteSegmentFetchCache(segment.fetchCache)) {
+			const fetchCache = segment.fetchCache;
+			if (hasParentDefaultNoStore && (fetchCache === "auto" || isCacheFetchCacheMode(fetchCache))) throw new Error(describeFetchCacheConflict(fetchCache));
+			if (fetchCache === "force-cache") hasForceCache = true;
+			if (fetchCache === "force-no-store") hasForceNoStore = true;
+			if (fetchCache === "only-cache") hasOnlyCache = true;
+			if (fetchCache === "only-no-store") hasOnlyNoStore = true;
+			if (hasForceCache && hasForceNoStore || !hasForceCache && !hasForceNoStore && hasOnlyCache && hasOnlyNoStore) throw new Error(describeFetchCacheConflict(fetchCache));
+			if (fetchCache === "default-no-store") hasParentDefaultNoStore = true;
+			if (hasForceCache) config.fetchCache = "force-cache";
+			else if (hasForceNoStore) config.fetchCache = "force-no-store";
+			else if (hasOnlyCache) config.fetchCache = "only-cache";
+			else if (hasOnlyNoStore) config.fetchCache = "only-no-store";
+			else if (config.fetchCache === void 0) config.fetchCache = fetchCache;
+		}
+		config.revalidateSeconds = resolveRevalidateSeconds(config.revalidateSeconds, segment.revalidate);
+	}
 	for (const segment of [options.page, ...options.parallelPages ?? []]) {
 		if (!segment) continue;
 		config.dynamicStaleTimeSeconds = resolveDynamicStaleTimeSeconds(config.dynamicStaleTimeSeconds, segment.unstable_dynamicStaleTime);
@@ -90,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;
@@ -76,6 +77,7 @@ type AppServerActionMatch<TRoute extends AppServerActionRoute> = {
 };
 type AppServerActionIntercept<TPage = unknown> = {
   matchedParams: AppPageParams;
+  sourceMatchedParams?: AppPageParams;
   page: TPage;
   slotId?: string | null;
   slotKey: string;
@@ -91,6 +93,8 @@ type BuildServerActionPageElementOptions<TRoute extends AppServerActionRoute, TI
   route: TRoute;
   searchParams: URLSearchParams;
   renderMode: AppRscRenderMode;
+  observeMetadataSearchParamsAccess?: boolean;
+  observePageSearchParamsAccess?: boolean;
 };
 type AppServerActionRscModel<TElement> = {
   /**
@@ -148,6 +152,7 @@ type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActio
   createRscOnErrorHandler: (request: Request, pathname: string, pattern: string) => (error: unknown) => unknown;
   createTemporaryReferenceSet: () => TTemporaryReferences;
   decodeReply: (body: string | FormData, options: DecodeServerActionReplyOptions<TTemporaryReferences>) => Promise<unknown[]> | unknown[];
+  draftModeSecret: string;
   /**
    * Hydrate a route's lazy page/route-handler modules before reading
    * `route.page` / `route.routeHandler` on action redirect targets and