vinext 0.1.1 → 0.1.3

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

@@ -4,27 +4,31 @@ import { getRequestExecutionContext } from "../shims/request-context.js";
 import { ACTION_REVALIDATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_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, validateImageUrl } from "./request-pipeline.js";
+import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
 import { headersContextFromRequest } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
-import { createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { mergeRewriteQuery } from "../utils/query.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
-import { isImageOptimizationPath } from "./image-optimization.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, resolveDevImageRedirect } from "./image-optimization.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
-import { prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { createAppPprFallbackShells } from "./app-ppr-fallback-shell.js";
+import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
 import { pickRootParams, setRootParams } from "../shims/root-params.js";
+import { flattenErrorCauses } from "../utils/error-cause.js";
 import { applyAppMiddleware } from "./app-middleware.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
 import { handleAppPrerenderEndpoint } from "./app-prerender-endpoints.js";
-import { flattenErrorCauses } from "../utils/error-cause.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"]);
 function applyMiddlewareContextToResponse(response, middlewareContext) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const headers = new Headers(response.headers);
@@ -38,6 +42,10 @@ function applyMiddlewareContextToResponse(response, middlewareContext) {
 function hasProperty(value, key) {
 	return key in value;
 }
+function isEdgeRouteHandler(handler) {
+	if (!handler || typeof handler !== "object" || !hasProperty(handler, "runtime")) return false;
+	return handler.runtime === "edge" || handler.runtime === "experimental-edge";
+}
 function isExecutionContextLike(value) {
 	if (!value || typeof value !== "object") return false;
 	return hasProperty(value, "waitUntil") && typeof value.waitUntil === "function";
@@ -56,6 +64,17 @@ async function applyRewrite(options, cleanPathname) {
 	}
 	return rewritten;
 }
+function requestContextForResolvedUrl(requestContext, resolvedUrl, baseUrl) {
+	return {
+		cookies: requestContext.cookies,
+		headers: requestContext.headers,
+		host: requestContext.host,
+		query: new URL(resolvedUrl, baseUrl).searchParams
+	};
+}
+function pathnameForResolvedUrl(resolvedUrl) {
+	return resolvedUrl.split("#", 1)[0].split("?", 1)[0];
+}
 function applyConfigHeadersToMiddlewareRedirect(response, options) {
 	if (response.status < 300 || response.status >= 400) return response;
 	if (!options.configHeaders.length) return response;
@@ -82,6 +101,13 @@ function requestWithoutRscCacheBustingSearchParam(request) {
 	stripRscCacheBustingSearchParam(url);
 	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
 }
+function requestWithoutRscSuffix(request) {
+	const url = new URL(request.url);
+	const pathname = stripRscSuffix(url.pathname);
+	if (pathname === url.pathname) return request;
+	url.pathname = pathname;
+	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
+}
 async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
@@ -92,6 +118,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (normalized instanceof Response) return normalized;
 	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest } = normalized;
 	let { pathname, cleanPathname } = normalized;
+	let resolvedUrl = cleanPathname + url.search;
+	const getResolvedSearchParams = () => new URL(resolvedUrl, url).searchParams;
 	const canonicalPathname = cleanPathname;
 	const basePathState = {
 		basePath: options.basePath,
@@ -124,12 +152,14 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		request
 	});
 	if (rscCacheBustingRedirect) return rscCacheBustingRedirect;
-	const userlandRequest = isRscRequest ? requestWithoutRscCacheBustingSearchParam(request) : request;
+	const normalizedUserlandRequest = requestWithoutRscSuffix(request);
+	const userlandRequest = requestWithoutRscCacheBustingSearchParam(normalizedUserlandRequest);
 	const middlewareContext = {
 		headers: null,
 		requestHeaders: null,
 		status: null
 	};
+	let didMiddlewareRewrite = false;
 	if (options.middlewareModule) {
 		const middlewareResult = await applyAppMiddleware({
 			basePath: options.basePath,
@@ -149,30 +179,46 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			requestContext: preMiddlewareRequestContext
 		});
 		cleanPathname = middlewareResult.cleanPathname;
+		didMiddlewareRewrite = 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);
-	const beforeFilesRewrite = await applyRewrite({
-		basePathState,
-		clearRequestContext: options.clearRequestContext,
-		request: userlandRequest,
-		requestContext: postMiddlewareRequestContext,
-		rewrites: options.configRewrites.beforeFiles
-	}, matchPathname(cleanPathname));
-	if (beforeFilesRewrite instanceof Response) return beforeFilesRewrite;
-	if (beforeFilesRewrite) cleanPathname = beforeFilesRewrite;
+	for (const rewrite of options.configRewrites.beforeFiles) {
+		const beforeFilesRewrite = await applyRewrite({
+			basePathState,
+			clearRequestContext: options.clearRequestContext,
+			request: normalizedUserlandRequest,
+			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			rewrites: [rewrite]
+		}, matchPathname(cleanPathname));
+		if (beforeFilesRewrite instanceof Response) return beforeFilesRewrite;
+		if (beforeFilesRewrite) {
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, beforeFilesRewrite);
+			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		}
+	}
 	if (isImageOptimizationPath(cleanPathname)) {
-		const imageUrlResult = validateImageUrl(url.searchParams.get("url"), request.url);
-		if (imageUrlResult instanceof Response) return imageUrlResult;
-		return Response.redirect(new URL(imageUrlResult, url.origin).href, 302);
+		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);
 	}
 	const metadataRouteResponse = await handleMetadataRouteRequest({
 		metadataRoutes: options.metadataRoutes,
 		cleanPathname,
 		makeThenableParams: options.makeThenableParams
 	});
-	if (metadataRouteResponse) return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
+	if (metadataRouteResponse) {
+		applyConfigHeadersToResponse(metadataRouteResponse.headers, {
+			basePathState,
+			configHeaders: options.configHeaders,
+			overwriteExisting: STATIC_METADATA_CONFIG_HEADER_OVERRIDES,
+			pathname: matchPathname(cleanPathname),
+			requestContext: preMiddlewareRequestContext
+		});
+		return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
+	}
 	const publicFileResponse = resolvePublicFileRoute({
 		cleanPathname,
 		middlewareContext,
@@ -184,10 +230,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		options.clearRequestContext();
 		return publicFileResponse;
 	}
-	if (isRscRequest) stripRscCacheBustingSearchParam(url);
+	stripRscCacheBustingSearchParam(url);
+	const resolved = new URL(resolvedUrl, url);
+	stripRscCacheBustingSearchParam(resolved);
+	resolvedUrl = resolved.pathname + resolved.search + resolved.hash;
 	options.setNavigationContext({
 		pathname: canonicalPathname,
-		searchParams: url.searchParams,
+		searchParams: getResolvedSearchParams(),
 		params: {}
 	});
 	const preActionMatch = options.matchRoute(cleanPathname);
@@ -216,53 +265,85 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		middlewareContext,
 		mountedSlotsHeader,
 		request,
-		searchParams: url.searchParams
+		searchParams: getResolvedSearchParams()
 	});
 	if (serverActionResponse) return serverActionResponse;
 	let match = preActionMatch;
-	if (!match || match.route.isDynamic) {
+	const renderPagesForMatchKind = async (matchKind) => match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
+		appRouteMatch: match ?? null,
+		allowRscDocumentFallback: didMiddlewareRewrite,
+		isRscRequest,
+		matchKind,
+		middlewareContext,
+		pathname: resolvedUrl,
+		request,
+		url
+	}) ?? null : null;
+	const staticPagesFallbackResponse = await renderPagesForMatchKind("static");
+	if (staticPagesFallbackResponse) {
+		options.clearRequestContext();
+		return staticPagesFallbackResponse;
+	}
+	if (!match || match.route.isDynamic) for (const rewrite of options.configRewrites.afterFiles) {
 		const afterFilesRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
-			request: userlandRequest,
-			requestContext: postMiddlewareRequestContext,
-			rewrites: options.configRewrites.afterFiles
+			request: normalizedUserlandRequest,
+			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			rewrites: [rewrite]
 		}, matchPathname(cleanPathname));
 		if (afterFilesRewrite instanceof Response) return afterFilesRewrite;
-		if (afterFilesRewrite) {
-			cleanPathname = afterFilesRewrite;
-			match = options.matchRoute(cleanPathname);
+		if (!afterFilesRewrite) continue;
+		resolvedUrl = mergeRewriteQuery(resolvedUrl, afterFilesRewrite);
+		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		match = options.matchRoute(cleanPathname);
+		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
+		if (rewrittenStaticPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenStaticPagesResponse;
 		}
+		const rewrittenDynamicPagesResponse = await renderPagesForMatchKind("dynamic");
+		if (rewrittenDynamicPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenDynamicPagesResponse;
+		}
+		if (match) break;
 	}
-	if (!match) {
+	const dynamicPagesFallbackResponse = await renderPagesForMatchKind("dynamic");
+	if (dynamicPagesFallbackResponse) {
+		options.clearRequestContext();
+		return dynamicPagesFallbackResponse;
+	}
+	if (!match) for (const rewrite of options.configRewrites.fallback) {
 		const fallbackRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
-			request: userlandRequest,
-			requestContext: postMiddlewareRequestContext,
-			rewrites: options.configRewrites.fallback
+			request: normalizedUserlandRequest,
+			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			rewrites: [rewrite]
 		}, matchPathname(cleanPathname));
 		if (fallbackRewrite instanceof Response) return fallbackRewrite;
-		if (fallbackRewrite) {
-			cleanPathname = fallbackRewrite;
-			match = options.matchRoute(cleanPathname);
+		if (!fallbackRewrite) continue;
+		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
+		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		match = options.matchRoute(cleanPathname);
+		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
+		if (rewrittenStaticPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenStaticPagesResponse;
+		}
+		const rewrittenDynamicPagesResponse = await renderPagesForMatchKind("dynamic");
+		if (rewrittenDynamicPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenDynamicPagesResponse;
 		}
+		if (match) break;
 	}
 	if (!match) {
 		if (process.env.NODE_ENV !== "production" && canonicalPathname === "/favicon.ico") {
 			options.clearRequestContext();
 			return new Response("", { status: 404 });
 		}
-		const pagesFallbackResponse = await options.renderPagesFallback?.({
-			isRscRequest,
-			middlewareContext,
-			request,
-			url
-		});
-		if (pagesFallbackResponse) {
-			options.clearRequestContext();
-			return pagesFallbackResponse;
-		}
 		const renderedNotFoundResponse = await options.renderNotFound({
 			isRscRequest,
 			middlewareContext,
@@ -278,25 +359,37 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}
 	const { route, params } = match;
 	if (options.ensureRouteLoaded) await options.ensureRouteLoaded(route);
-	const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
-	const prerenderRouteParams = prerenderRouteParamsPayloadMatchesRoute(prerenderRouteParamsPayload, route.pattern, params) ? prerenderRouteParamsPayload.params : null;
+	const prerenderRouteParamsMatch = matchPrerenderRouteParamsPayload(readTrustedPrerenderRouteParams(request), route.pattern, params);
+	const prerenderRouteParams = prerenderRouteParamsMatch?.params ?? null;
+	const isPrerenderFallbackShell = prerenderRouteParamsMatch?.kind === "fallback-shell";
 	const renderParams = prerenderRouteParams ?? params;
+	const resolvedSearchParams = getResolvedSearchParams();
+	const runtimeFallbackShells = options.cacheComponents === true && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params ? createAppPprFallbackShells({
+		params: route.params,
+		pattern: route.pattern,
+		rootParamNames: route.rootParamNames
+	}, params) : [];
 	options.setNavigationContext({
 		pathname: canonicalPathname,
-		searchParams: url.searchParams,
+		searchParams: resolvedSearchParams,
 		params: renderParams
 	});
 	const rootParams = pickRootParams(renderParams, route.rootParamNames);
 	setRootParams(rootParams);
 	if (route.routeHandler) {
 		setCurrentFetchSoftTags(buildPageCacheTags(cleanPathname, [], [...route.routeSegments], "route"));
+		const routeHandlerRequest = isEdgeRouteHandler(route.routeHandler) ? userlandRequest : normalizedUserlandRequest;
+		const routeHandlerUrl = new URL(routeHandlerRequest.url);
+		const internalRscValues = isEdgeRouteHandler(route.routeHandler) ? [] : routeHandlerUrl.searchParams.getAll(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
+		routeHandlerUrl.search = resolvedSearchParams.toString();
+		for (const internalRscValue of internalRscValues) routeHandlerUrl.searchParams.append(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, internalRscValue);
 		return options.dispatchMatchedRouteHandler({
 			cleanPathname,
 			middlewareContext,
 			params: route.isDynamic ? renderParams : null,
-			request,
+			request: new Request(routeHandlerUrl, routeHandlerRequest),
 			route,
-			searchParams: url.searchParams
+			searchParams: resolvedSearchParams
 		});
 	}
 	const pageResponse = await options.dispatchMatchedPage({
@@ -313,12 +406,19 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		middlewareContext,
 		mountedSlotsHeader,
 		params: renderParams,
-		staticParamsValidationParams: prerenderRouteParams === null ? void 0 : params,
+		pprFallbackCacheShells: runtimeFallbackShells,
+		pprFallbackShell: isPrerenderFallbackShell ? {
+			fallbackParamNames: prerenderRouteParamsMatch.fallbackParamNames,
+			routePattern: route.pattern
+		} : void 0,
+		renderedConcreteUrlPaths: getRenderedConcreteUrlPathsForRoute(route.pattern),
+		skipStaticParamsValidation: isPrerenderFallbackShell,
+		staticParamsValidationParams: prerenderRouteParams === null || isPrerenderFallbackShell ? void 0 : params,
 		rootParams,
 		request,
 		route,
 		scriptNonce,
-		searchParams: url.searchParams,
+		searchParams: resolvedSearchParams,
 		renderMode
 	});
 	if (isProgressiveActionRender) return applyProgressiveActionSideEffects(pageResponse, progressiveActionResult);

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

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

package/dist/server/app-rsc-route-matching.d.ts

@@ -29,6 +29,7 @@ type AppRscInterceptForMatching = {
    * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/lib/generate-interception-routes-rewrites.ts
    */
   sourceMatchPattern?: string;
+  sourcePageSegments?: readonly string[];
   interceptLayouts: readonly unknown[];
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
@@ -41,6 +42,7 @@ type AppRscSlotForMatching = {
 type AppRscSiblingInterceptForMatching = {
   targetPattern: string;
   sourceMatchPattern: string | null;
+  sourcePageSegments?: readonly string[];
   slotId: string | null;
   interceptLayouts: readonly unknown[];
   page: unknown;
@@ -63,6 +65,7 @@ type AppRscInterceptLookupEntry = {
   targetPatternParts: string[];
   sourceMatchPattern: string | null;
   sourceMatchPatternParts: string[] | null;
+  sourcePageSegments: readonly string[] | null;
   interceptLayouts: readonly unknown[];
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;

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

@@ -78,6 +78,7 @@ function createInterceptLookup(routes) {
 					targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
 					sourceMatchPattern,
 					sourceMatchPatternParts,
+					sourcePageSegments: intercept.sourcePageSegments ?? null,
 					interceptLayouts: intercept.interceptLayouts,
 					page: intercept.page,
 					__pageLoader: intercept.__pageLoader,
@@ -96,6 +97,7 @@ function createInterceptLookup(routes) {
 				targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
 				sourceMatchPattern,
 				sourceMatchPatternParts,
+				sourcePageSegments: intercept.sourcePageSegments ?? null,
 				interceptLayouts: intercept.interceptLayouts,
 				page: intercept.page,
 				__pageLoader: intercept.__pageLoader,

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

@@ -33,6 +33,14 @@ type ResolveAppPageSegmentConfigOptions = {
  */
 declare function resolveAppPageSegmentConfig(options: ResolveAppPageSegmentConfigOptions): EffectiveAppPageSegmentConfig;
 declare function resolveAppPageFetchCacheMode(options: ResolveAppPageSegmentConfigOptions): FetchCacheMode | null;
+/**
+ * Resolve the `fetchCache` segment config exported by a route handler module.
+ *
+ * Route handlers have no layout chain, so the module's own export applies
+ * directly. Mirrors upstream's app-route module, which copies
+ * `userland.fetchCache` into the work store before invoking the handler.
+ */
+declare function resolveAppRouteHandlerFetchCacheMode(handler: Pick<AppRouteSegmentConfigModule, "fetchCache">): FetchCacheMode | null;
 declare function isEdgeRuntime(runtime: string | undefined): boolean;
 //#endregion
-export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };
+export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig, resolveAppRouteHandlerFetchCacheMode };

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

@@ -88,8 +88,7 @@ function resolveAppPageSegmentConfig(options) {
 	}
 	if (config.dynamicConfig === "force-dynamic") config.revalidateSeconds = 0;
 	if (config.fetchCache === void 0) {
-		if (config.dynamicConfig === "force-dynamic") config.fetchCache = "force-no-store";
-		else if (config.dynamicConfig === "error") config.fetchCache = "only-cache";
+		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;
@@ -97,8 +96,18 @@ function resolveAppPageSegmentConfig(options) {
 function resolveAppPageFetchCacheMode(options) {
 	return resolveAppPageSegmentConfig(options).fetchCache ?? null;
 }
+/**
+* Resolve the `fetchCache` segment config exported by a route handler module.
+*
+* Route handlers have no layout chain, so the module's own export applies
+* directly. Mirrors upstream's app-route module, which copies
+* `userland.fetchCache` into the work store before invoking the handler.
+*/
+function resolveAppRouteHandlerFetchCacheMode(handler) {
+	return isRouteSegmentFetchCache(handler.fetchCache) ? handler.fetchCache : null;
+}
 function isEdgeRuntime(runtime) {
 	return isEdgeApiRuntime(runtime);
 }
 //#endregion
-export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };
+export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig, resolveAppRouteHandlerFetchCacheMode };

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

@@ -31,6 +31,17 @@ type AppServerActionRoute = {
   pattern: string;
   routeHandler?: unknown;
   routeSegments?: readonly string[];
+  params?: readonly string[] | null;
+  slots?: Readonly<Record<string, {
+    default?: {
+      default?: unknown;
+    } | null;
+    page?: {
+      default?: unknown;
+    } | null;
+    slotPatternParts?: readonly string[] | null;
+    slotParamNames?: readonly string[] | null;
+  }>> | null;
 };
 /**
  * Side-effect headers captured during a progressive (no-JS) server action's
@@ -162,6 +173,7 @@ type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActio
   renderToReadableStream: (model: AppServerActionRscModel<TElement>, options: RenderServerActionRscStreamOptions<TTemporaryReferences>) => BodyInit | null | Promise<BodyInit | null>;
   reportRequestError: AppServerActionErrorReporter;
   resolveRouteFetchCacheMode?: (route: TRoute) => FetchCacheMode | null;
+  resolveRouteDynamicConfig?: (route: TRoute) => string | null | undefined;
   resolveRouteRuntime?: (route: TRoute) => AppServerActionRouteRuntime;
   request: Request;
   sanitizeErrorForClient: (error: unknown) => unknown;

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

@@ -7,7 +7,7 @@ import { validateCsrfOrigin, validateServerActionPayload } from "./request-pipel
 import { headersContextFromRequest, setHeadersContext } from "../shims/headers.js";
 import { getAndClearActionRevalidationKind } from "../shims/cache.js";
 import { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI } from "./app-rsc-render-mode.js";
-import { setCurrentFetchCacheMode, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
@@ -15,8 +15,9 @@ import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { deferUntilStreamConsumed } from "./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 { buildPageCacheTags } from "./implicit-tags.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-server-action-execution.ts
 /**
@@ -45,6 +46,10 @@ function resolveActionRevalidationKind(hasModifiedCookies) {
 	if (hasModifiedCookies) return ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC;
 	return revalidationKind;
 }
+function clearRejectedActionSideEffects(getAndClearPendingCookies) {
+	getAndClearPendingCookies();
+	getAndClearActionRevalidationKind();
+}
 function cloneActionRedirectHeaders(requestHeaders) {
 	const headers = new Headers(requestHeaders);
 	for (const header of ACTION_REDIRECT_RENDER_STRIPPED_HEADERS) headers.delete(header);
@@ -232,7 +237,7 @@ function applyActionRedirectBasePath(url, basePath) {
 	return `${addBasePathToPathname(pathname, basePath)}${suffix}`;
 }
 function buildServerActionPageTags(route, pathname) {
-	return buildPageCacheTags(pathname, [], [...route.routeSegments ?? []], "page");
+	return buildAppPageTags(pathname, [], route.routeSegments ?? []);
 }
 function resolveInternalActionRedirectTarget(redirectUrl, requestUrl, basePath) {
 	if (isExternalUrl(redirectUrl)) {
@@ -330,6 +335,7 @@ async function handleProgressiveServerActionRequest(options) {
 		}
 		const payloadResponse = await validateServerActionPayload(body);
 		if (payloadResponse) {
+			clearRejectedActionSideEffects(options.getAndClearPendingCookies);
 			options.clearRequestContext();
 			return payloadResponse;
 		}
@@ -481,6 +487,24 @@ async function handleServerActionRscRequest(options) {
 	if (csrfResponse) return csrfResponse;
 	if (parseInt(options.request.headers.get("content-length") || "0", 10) > options.maxActionBodySize) return renderFetchActionBodyExceededResponse(options);
 	try {
+		let action;
+		if (options.contentType.startsWith("multipart/form-data")) {
+			let loadedAction;
+			try {
+				loadedAction = await options.loadServerAction(options.actionId);
+			} catch (error) {
+				if (isServerActionNotFoundError(error, options.actionId)) return createActionNotFoundResponse(options.actionId, {
+					clearRequestContext: options.clearRequestContext,
+					getAndClearPendingCookies: options.getAndClearPendingCookies
+				});
+				throw error;
+			}
+			if (!isAppServerActionFunction(loadedAction)) return createActionNotFoundResponse(options.actionId, {
+				clearRequestContext: options.clearRequestContext,
+				getAndClearPendingCookies: options.getAndClearPendingCookies
+			});
+			action = loadedAction;
+		}
 		let body;
 		try {
 			body = options.contentType.startsWith("multipart/form-data") ? await options.readFormDataWithLimit(options.request, options.maxActionBodySize) : await options.readBodyWithLimit(options.request, options.maxActionBodySize);
@@ -490,23 +514,27 @@ async function handleServerActionRscRequest(options) {
 		}
 		const payloadResponse = await validateServerActionPayload(body);
 		if (payloadResponse) {
+			clearRejectedActionSideEffects(options.getAndClearPendingCookies);
 			options.clearRequestContext();
 			return payloadResponse;
 		}
-		let action;
-		try {
-			action = await options.loadServerAction(options.actionId);
-		} catch (error) {
-			if (isServerActionNotFoundError(error, options.actionId)) return createActionNotFoundResponse(options.actionId, {
+		if (action === void 0) {
+			let loadedAction;
+			try {
+				loadedAction = await options.loadServerAction(options.actionId);
+			} catch (error) {
+				if (isServerActionNotFoundError(error, options.actionId)) return createActionNotFoundResponse(options.actionId, {
+					clearRequestContext: options.clearRequestContext,
+					getAndClearPendingCookies: options.getAndClearPendingCookies
+				});
+				throw error;
+			}
+			if (!isAppServerActionFunction(loadedAction)) return createActionNotFoundResponse(options.actionId, {
 				clearRequestContext: options.clearRequestContext,
 				getAndClearPendingCookies: options.getAndClearPendingCookies
 			});
-			throw error;
+			action = loadedAction;
 		}
-		if (!isAppServerActionFunction(action)) return createActionNotFoundResponse(options.actionId, {
-			clearRequestContext: options.clearRequestContext,
-			getAndClearPendingCookies: options.getAndClearPendingCookies
-		});
 		const temporaryReferences = options.createTemporaryReferenceSet();
 		const args = await options.decodeReply(body, { temporaryReferences });
 		let returnValue;
@@ -591,12 +619,14 @@ async function handleServerActionRscRequest(options) {
 				url: redirectTarget
 			});
 			setHeadersContext(headersContextFromRequest(redirectRenderRequest));
+			const redirectNavigationParams = resolveAppPageNavigationParams(targetMatch.route, targetMatch.params, targetPathname, null);
 			options.setNavigationContext({
 				pathname: targetPathname,
 				searchParams: redirectTarget.searchParams,
-				params: targetMatch.params
+				params: redirectNavigationParams
 			});
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(targetMatch.route) ?? null);
+			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(targetMatch.route) === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(targetMatch.route, targetPathname));
 			const element = options.buildPageElement({
 				cleanPathname: targetPathname,
@@ -667,13 +697,15 @@ async function handleServerActionRscRequest(options) {
 				isRscRequest: options.isRscRequest,
 				toInterceptOpts: options.toInterceptOpts
 			});
+			const resolvedActionNavigationParams = resolveAppPageNavigationParams(actionRerenderTarget.route, actionRerenderTarget.navigationParams, options.cleanPathname, actionRerenderTarget.interceptOpts);
 			options.setNavigationContext({
 				pathname: options.cleanPathname,
 				searchParams: options.searchParams,
-				params: actionRerenderTarget.navigationParams
+				params: resolvedActionNavigationParams
 			});
 			await options.ensureRouteLoaded?.(actionRerenderTarget.route);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(actionRerenderTarget.route) ?? null);
+			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(actionRerenderTarget.route) === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(actionRerenderTarget.route, options.cleanPathname));
 			element = options.buildPageElement({
 				cleanPathname: options.cleanPathname,

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

@@ -22,6 +22,7 @@ declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navContext: Na
   capturedRscDataRef?: {
     value: Promise<ArrayBuffer> | null;
   };
+  pprFallbackShellSignal?: AbortSignal;
   formState?: ReactFormState | null;
   basePath?: string;
   /**
@@ -42,6 +43,7 @@ declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navContext: Na
    *  to resolve before returning the HTML stream. Used for static prerender
    *  and ISR cache writes to avoid caching fallback content. */
   waitForAllReady?: boolean;
+  fallbackToErrorDocumentOnShellError?: boolean;
 }): Promise<AppSsrRenderResult>;
 declare const _default: {
   fetch(request: Request): Promise<Response>;