vinext 0.1.7 → 0.2.0

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

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

@@ -5,7 +5,7 @@ import { isExternalUrl } from "../config/config-matchers.js";
 import { internalServerErrorResponse, payloadTooLargeResponse } from "./http-error-responses.js";
 import { validateCsrfOrigin, validateServerActionPayload } from "./request-pipeline.js";
 import { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI } from "./app-rsc-render-mode.js";
-import { headersContextFromRequest, setHeadersContext } from "../shims/headers.js";
+import { headersContextFromRequest, isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { getAndClearActionRevalidationKind } from "../shims/cache-request-state.js";
 import { setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
@@ -19,8 +19,31 @@ import "./app-page-stream.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { resolveAppPageActionRerenderTarget } from "./app-page-request.js";
+import { createRootParamsUsageController, pickRootParams, runWithRootParamsScope, runWithRootParamsUsage } from "../shims/root-params.js";
 import { getSetCookieName } from "./cookie-utils.js";
+import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 //#region src/server/app-server-action-execution.ts
+function prepareActionPageRerenderContext(options) {
+	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") setHeadersContext(createStaticGenerationHeadersContext({
+		draftModeEnabled: isDraftModeRequest(createActionRerenderRequest({
+			draftModeCookie: options.draftModeCookie,
+			request: options.request
+		}), options.draftModeSecret),
+		draftModeSecret: options.draftModeSecret,
+		dynamicConfig: options.dynamicConfig,
+		routeKind: "page",
+		routePattern: options.routePattern
+	}));
+	return options.dynamicConfig === "force-static" ? new URLSearchParams() : options.searchParams;
+}
+function createActionRerenderRequest(options) {
+	if (!options.draftModeCookie) return options.request;
+	const headers = new Headers(options.request.headers);
+	const cookieHeader = applySetCookieMutationsToRequestCookieHeader(headers.get("cookie"), [options.draftModeCookie]);
+	if (cookieHeader === null) headers.delete("cookie");
+	else headers.set("cookie", cookieHeader);
+	return new Request(options.request.url, { headers });
+}
 /**
 * Matches Next.js' server action argument cap to prevent stack overflow in
 * Function.prototype.apply when decoding hostile action payloads.
@@ -351,11 +374,14 @@ async function handleProgressiveServerActionRequest(options) {
 		let actionRedirect = null;
 		let actionError = void 0;
 		let actionFailed = false;
+		let actionThrew = false;
 		let actionResult;
+		const rootParamsUsage = createRootParamsUsageController();
 		const previousHeadersPhase = options.setHeadersAccessPhase("action");
 		try {
-			actionResult = await action();
+			actionResult = await runWithRootParamsUsage({ kind: "server-action" }, action, rootParamsUsage);
 		} catch (error) {
+			actionThrew = true;
 			actionRedirect = getActionRedirect(error);
 			if (!actionRedirect) {
 				actionError = error;
@@ -375,8 +401,10 @@ async function handleProgressiveServerActionRequest(options) {
 			}
 		} finally {
 			options.setHeadersAccessPhase(previousHeadersPhase);
+			if (actionThrew) rootParamsUsage.transitionToRender();
 		}
 		if (!actionRedirect) {
+			if (!actionThrew) rootParamsUsage.transitionToRender();
 			const actionPendingCookies = dedupePendingCookies(options.getAndClearPendingCookies());
 			const actionDraftCookie = options.getDraftModeCookieHeader();
 			const revalidationKind = resolveActionRevalidationKind(actionPendingCookies.length > 0 || Boolean(actionDraftCookie));
@@ -544,16 +572,19 @@ async function handleServerActionRscRequest(options) {
 		let returnValue;
 		let actionRedirect = null;
 		let actionStatus = 200;
+		let actionThrew = false;
 		const actionWasForwarded = Boolean(options.request.headers.get(ACTION_FORWARDED_HEADER));
+		const rootParamsUsage = createRootParamsUsageController();
 		const previousHeadersPhase = options.setHeadersAccessPhase("action");
 		try {
 			try {
 				validateServerActionArgs(args);
 				returnValue = {
 					ok: true,
-					data: await action.apply(null, args)
+					data: await runWithRootParamsUsage({ kind: "server-action" }, () => action.apply(null, args), rootParamsUsage)
 				};
 			} catch (error) {
+				actionThrew = true;
 				actionRedirect = getActionRedirect(error);
 				if (actionRedirect) returnValue = {
 					ok: true,
@@ -568,6 +599,7 @@ async function handleServerActionRscRequest(options) {
 							data: error
 						};
 					} else {
+						actionStatus = 500;
 						console.error("[vinext] Server action error:", error);
 						returnValue = {
 							ok: false,
@@ -578,6 +610,7 @@ async function handleServerActionRscRequest(options) {
 			}
 		} finally {
 			options.setHeadersAccessPhase(previousHeadersPhase);
+			if (actionThrew && !actionWasForwarded) rootParamsUsage.transitionToRender();
 		}
 		if (actionRedirect) {
 			const actionPendingCookies = dedupePendingCookies(options.getAndClearPendingCookies());
@@ -622,35 +655,48 @@ async function handleServerActionRscRequest(options) {
 				request: options.request,
 				url: redirectTarget
 			});
-			setHeadersContext(headersContextFromRequest(redirectRenderRequest));
+			setHeadersContext(headersContextFromRequest(redirectRenderRequest, { draftModeSecret: options.draftModeSecret }));
+			const redirectDynamicConfig = options.resolveRouteDynamicConfig?.(targetMatch.route);
+			const redirectSearchParams = prepareActionPageRerenderContext({
+				draftModeCookie: actionDraftCookie,
+				draftModeSecret: options.draftModeSecret,
+				dynamicConfig: redirectDynamicConfig,
+				request: redirectRenderRequest,
+				routePattern: targetMatch.route.pattern,
+				searchParams: redirectTarget.searchParams
+			});
 			const redirectNavigationParams = resolveAppPageNavigationParams(targetMatch.route, targetMatch.params, targetPathname, null);
 			options.setNavigationContext({
 				pathname: targetPathname,
-				searchParams: redirectTarget.searchParams,
+				searchParams: redirectSearchParams,
 				params: redirectNavigationParams
 			});
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(targetMatch.route) ?? null);
-			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(targetMatch.route) === "force-dynamic");
+			setCurrentForceDynamicFetchDefault(redirectDynamicConfig === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(targetMatch.route, targetPathname));
-			const element = options.buildPageElement({
-				cleanPathname: targetPathname,
-				interceptOpts: void 0,
-				isRscRequest: true,
-				mountedSlotsHeader: null,
-				params: targetMatch.params,
-				request: redirectRenderRequest,
-				route: targetMatch.route,
-				searchParams: redirectTarget.searchParams,
-				renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI
-			});
-			const onRenderError = options.createRscOnErrorHandler(redirectRenderRequest, targetPathname, targetMatch.route.pattern);
-			return createServerActionRscResponse(await options.renderToReadableStream({
-				root: element,
-				returnValue
-			}, {
-				temporaryReferences,
-				onError: onRenderError
-			}), {
+			return createServerActionRscResponse(await runWithRootParamsScope(pickRootParams(targetMatch.params, targetMatch.route.rootParamNames), () => runWithRootParamsUsage({ kind: "route" }, async () => {
+				const element = options.buildPageElement({
+					cleanPathname: targetPathname,
+					interceptOpts: void 0,
+					isRscRequest: true,
+					mountedSlotsHeader: null,
+					params: targetMatch.params,
+					request: redirectRenderRequest,
+					route: targetMatch.route,
+					searchParams: redirectSearchParams,
+					renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI,
+					observeMetadataSearchParamsAccess: redirectDynamicConfig !== "force-static",
+					observePageSearchParamsAccess: redirectDynamicConfig !== "force-static"
+				});
+				const onRenderError = options.createRscOnErrorHandler(redirectRenderRequest, targetPathname, targetMatch.route.pattern);
+				return options.renderToReadableStream({
+					root: element,
+					returnValue
+				}, {
+					temporaryReferences,
+					onError: onRenderError
+				});
+			})), {
 				status: shouldUseForwardedActionRedirectStatus({
 					actionWasForwarded,
 					currentPathname: options.cleanPathname,
@@ -665,7 +711,8 @@ async function handleServerActionRscRequest(options) {
 		const actionPendingCookies = dedupePendingCookies(options.getAndClearPendingCookies());
 		const actionDraftCookie = options.getDraftModeCookieHeader();
 		const actionRevalidationKind = resolveActionRevalidationKind(actionPendingCookies.length > 0 || Boolean(actionDraftCookie));
-		if (actionWasForwarded || actionStatus === 200 && actionRevalidationKind === ACTION_DID_NOT_REVALIDATE) {
+		const isHttpFallback = actionStatus === 401 || actionStatus === 403 || actionStatus === 404;
+		if (!isHttpFallback && (actionWasForwarded || actionRevalidationKind === ACTION_DID_NOT_REVALIDATE)) {
 			const onRenderError = options.createRscOnErrorHandler(options.request, options.cleanPathname, options.cleanPathname);
 			const rscStream = await options.renderToReadableStream({ returnValue }, {
 				temporaryReferences,
@@ -686,6 +733,7 @@ async function handleServerActionRscRequest(options) {
 				headers: actionHeaders
 			}, options.clearRequestContext);
 		}
+		if (!actionThrew) rootParamsUsage.transitionToRender();
 		const match = options.matchRoute(options.cleanPathname);
 		let element;
 		let errorPattern = match ? match.route.pattern : options.cleanPathname;
@@ -702,16 +750,25 @@ async function handleServerActionRscRequest(options) {
 				toInterceptOpts: options.toInterceptOpts
 			});
 			const resolvedActionNavigationParams = resolveAppPageNavigationParams(actionRerenderTarget.route, actionRerenderTarget.navigationParams, options.cleanPathname, actionRerenderTarget.interceptOpts);
+			await options.ensureRouteLoaded?.(actionRerenderTarget.route);
+			const actionRerenderDynamicConfig = options.resolveRouteDynamicConfig?.(actionRerenderTarget.route);
+			const actionRerenderSearchParams = prepareActionPageRerenderContext({
+				draftModeCookie: actionDraftCookie,
+				draftModeSecret: options.draftModeSecret,
+				dynamicConfig: actionRerenderDynamicConfig,
+				request: options.request,
+				routePattern: actionRerenderTarget.route.pattern,
+				searchParams: options.searchParams
+			});
 			options.setNavigationContext({
 				pathname: options.cleanPathname,
-				searchParams: options.searchParams,
+				searchParams: actionRerenderSearchParams,
 				params: resolvedActionNavigationParams
 			});
-			await options.ensureRouteLoaded?.(actionRerenderTarget.route);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(actionRerenderTarget.route) ?? null);
-			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(actionRerenderTarget.route) === "force-dynamic");
+			setCurrentForceDynamicFetchDefault(actionRerenderDynamicConfig === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(actionRerenderTarget.route, options.cleanPathname));
-			element = options.buildPageElement({
+			const buildActionRerenderElement = () => options.buildPageElement({
 				cleanPathname: options.cleanPathname,
 				interceptOpts: actionRerenderTarget.interceptOpts,
 				isRscRequest: options.isRscRequest,
@@ -719,22 +776,26 @@ async function handleServerActionRscRequest(options) {
 				params: actionRerenderTarget.params,
 				request: options.request,
 				route: actionRerenderTarget.route,
-				searchParams: options.searchParams,
-				renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI
+				searchParams: actionRerenderSearchParams,
+				renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI,
+				observeMetadataSearchParamsAccess: actionRerenderDynamicConfig !== "force-static",
+				observePageSearchParamsAccess: actionRerenderDynamicConfig !== "force-static"
 			});
+			element = actionWasForwarded && isHttpFallback ? await runWithRootParamsUsage({ kind: "route" }, async () => buildActionRerenderElement()) : buildActionRerenderElement();
 			errorPattern = actionRerenderTarget.route.pattern;
 		} else {
 			const actionRouteId = options.createPayloadRouteId(options.cleanPathname, null);
 			element = options.createNotFoundElement(actionRouteId);
 		}
 		const onRenderError = options.createRscOnErrorHandler(options.request, options.cleanPathname, errorPattern);
-		const rscStream = await options.renderToReadableStream({
+		const renderActionRerender = () => options.renderToReadableStream({
 			root: element,
 			returnValue
 		}, {
 			temporaryReferences,
 			onError: onRenderError
 		});
+		const rscStream = await (actionWasForwarded && isHttpFallback ? runWithRootParamsUsage({ kind: "route" }, renderActionRerender) : renderActionRerender());
 		const actionHeaders = new Headers({
 			"Content-Type": VINEXT_RSC_CONTENT_TYPE,
 			Vary: VINEXT_RSC_VARY_HEADER

package/dist/server/app-ssr-entry.d.ts

@@ -1,5 +1,6 @@
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import { RootParams } from "../shims/root-params.js";
+import { InitialNavigationCacheMetadata } from "./app-ssr-stream.js";
 import { AppSsrRenderResult } from "./app-page-stream.js";
 import { ReactFormState } from "react-dom/client";
 
@@ -44,6 +45,8 @@ declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navContext: Na
    *  and ISR cache writes to avoid caching fallback content. */
   waitForAllReady?: boolean;
   fallbackToErrorDocumentOnShellError?: boolean;
+  dynamicStaleTimeSeconds?: number;
+  getInitialNavigationCacheMetadata?: () => InitialNavigationCacheMetadata;
 }): Promise<AppSsrRenderResult>;
 declare const _default: {
   fetch(request: Request): Promise<Response>;