vinext 0.0.54 → 0.1.0

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

@@ -88,5 +88,3 @@ function mergeMatchedParams(sourceParams, targetParams) {
 }
 //#endregion
 export { createAppRscRouteMatcher, matchAppRscRoutePattern };
-
-//# sourceMappingURL=app-rsc-route-matching.js.map

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

@@ -8,17 +8,20 @@ type AppRouteSegmentConfigModule = {
   fetchCache?: unknown;
   revalidate?: unknown;
   runtime?: unknown;
+  unstable_dynamicStaleTime?: unknown;
 };
 type EffectiveAppPageSegmentConfig = {
   dynamicConfig?: AppRouteSegmentDynamic;
   dynamicParamsConfig?: boolean;
+  dynamicStaleTimeSeconds?: number;
   fetchCache?: FetchCacheMode;
   revalidateSeconds: number | null;
-  runtime?: string;
+  runtime?: "edge" | "experimental-edge" | "nodejs";
 };
 type ResolveAppPageSegmentConfigOptions = {
   layouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
   page?: AppRouteSegmentConfigModule | null;
+  parallelPages?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
 };
 /**
  * Resolve the route segment config that applies to an App page route.
@@ -32,5 +35,4 @@ declare function resolveAppPageSegmentConfig(options: ResolveAppPageSegmentConfi
 declare function resolveAppPageFetchCacheMode(options: ResolveAppPageSegmentConfigOptions): FetchCacheMode | null;
 declare function isEdgeRuntime(runtime: string | undefined): boolean;
 //#endregion
-export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };
-//# sourceMappingURL=app-segment-config.d.ts.map
+export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };

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

@@ -21,6 +21,9 @@ function isRouteSegmentDynamic(value) {
 function isRouteSegmentFetchCache(value) {
 	return FETCH_CACHE_VALUES.has(value);
 }
+function isRouteSegmentRuntime(value) {
+	return value === "edge" || value === "experimental-edge" || value === "nodejs";
+}
 function resolveRevalidateSeconds(current, value) {
 	if (value === false) {
 		if (current === null) return Infinity;
@@ -30,6 +33,10 @@ function resolveRevalidateSeconds(current, value) {
 	if (current === null) return value;
 	return value < current ? value : current;
 }
+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 isCacheFetchCacheMode(value) {
 	return value === "default-cache" || value === "force-cache" || value === "only-cache";
 }
@@ -55,6 +62,7 @@ function resolveAppPageSegmentConfig(options) {
 	for (const segment of segments) {
 		if (!segment) continue;
 		if (isRouteSegmentDynamic(segment.dynamic)) config.dynamicConfig = 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)) {
@@ -73,7 +81,10 @@ function resolveAppPageSegmentConfig(options) {
 			else config.fetchCache = fetchCache;
 		}
 		config.revalidateSeconds = resolveRevalidateSeconds(config.revalidateSeconds, segment.revalidate);
-		if (typeof segment.runtime === "string") config.runtime = segment.runtime;
+	}
+	for (const segment of [options.page, ...options.parallelPages ?? []]) {
+		if (!segment) continue;
+		config.dynamicStaleTimeSeconds = resolveDynamicStaleTimeSeconds(config.dynamicStaleTimeSeconds, segment.unstable_dynamicStaleTime);
 	}
 	if (config.dynamicConfig === "force-dynamic") config.revalidateSeconds = 0;
 	if (config.fetchCache === void 0) {
@@ -91,5 +102,3 @@ function isEdgeRuntime(runtime) {
 }
 //#endregion
 export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };
-
-//# sourceMappingURL=app-segment-config.js.map

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

@@ -27,7 +27,10 @@ type AppServerActionReturnValue = {
   ok: false;
 };
 type AppServerActionRoute = {
+  page?: unknown;
   pattern: string;
+  routeHandler?: unknown;
+  routeSegments?: readonly string[];
 };
 /**
  * Side-effect headers captured during a progressive (no-JS) server action's
@@ -46,6 +49,7 @@ type ProgressiveServerActionSideEffects = {
   draftCookie: string | null | undefined; /** Resolved revalidation kind to emit via `x-action-revalidated`. */
   revalidationKind: ActionRevalidationKind;
 };
+type AppServerActionRouteRuntime = "edge" | "experimental-edge" | "nodejs" | null;
 type ProgressiveServerActionResult = ({
   formState: ReactFormState | null;
   kind: "form-state";
@@ -124,6 +128,12 @@ 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[];
+  /**
+   * Hydrate a route's lazy page/route-handler modules before reading
+   * `route.page` / `route.routeHandler` on action redirect targets and
+   * re-render targets obtained via `matchRoute`/`getSourceRoute`. Idempotent.
+   */
+  ensureRouteLoaded?: (route: TRoute) => unknown;
   findIntercept: (pathname: string) => AppServerActionIntercept<TPage> | null;
   getAndClearPendingCookies: () => string[];
   getDraftModeCookieHeader: () => string | null | undefined;
@@ -142,6 +152,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;
+  resolveRouteRuntime?: (route: TRoute) => AppServerActionRouteRuntime;
   request: Request;
   sanitizeErrorForClient: (error: unknown) => unknown;
   searchParams: URLSearchParams;
@@ -183,5 +194,4 @@ declare function isProgressiveServerActionRequest(request: Pick<Request, "method
 declare function handleProgressiveServerActionRequest(options: HandleProgressiveServerActionRequestOptions): Promise<Response | ProgressiveServerActionResult | null>;
 declare function handleServerActionRscRequest<TElement, TRoute extends AppServerActionRoute, TInterceptOpts, TTemporaryReferences, TPage = unknown>(options: HandleServerActionRscRequestOptions<TElement, TRoute, TInterceptOpts, TTemporaryReferences, TPage>): Promise<Response | null>;
 //#endregion
-export { HandleProgressiveServerActionRequestOptions, HandleServerActionRscRequestOptions, applyActionRedirectBasePath, handleProgressiveServerActionRequest, handleServerActionRscRequest, isProgressiveServerActionRequest, readActionBodyWithLimit, readActionFormDataWithLimit };
-//# sourceMappingURL=app-server-action-execution.d.ts.map
+export { HandleProgressiveServerActionRequestOptions, HandleServerActionRscRequestOptions, applyActionRedirectBasePath, handleProgressiveServerActionRequest, handleServerActionRscRequest, isProgressiveServerActionRequest, readActionBodyWithLimit, readActionFormDataWithLimit };

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

@@ -1,18 +1,22 @@
-import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
-import { ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER } from "./headers.js";
+import { splitPathSegments } from "../routing/utils.js";
+import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
+import { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER } from "./headers.js";
 import { isExternalUrl } from "../config/config-matchers.js";
 import { internalServerErrorResponse, payloadTooLargeResponse } from "./http-error-responses.js";
 import { validateCsrfOrigin, validateServerActionPayload } from "./request-pipeline.js";
+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 } from "../shims/fetch-cache.js";
+import { setCurrentFetchCacheMode, setCurrentFetchSoftTags } 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 { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 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 { 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
 /**
@@ -22,6 +26,16 @@ import { getSetCookieName } from "./cookie-utils.js";
 const SERVER_ACTION_ARGS_LIMIT = 1e3;
 const ACTION_DID_NOT_REVALIDATE = 0;
 const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
+const ACTION_REDIRECT_RENDER_STRIPPED_HEADERS = [
+	"accept",
+	"content-length",
+	"content-type",
+	"next-action",
+	"origin",
+	"rsc",
+	"x-action-forwarded",
+	"x-rsc-action"
+];
 function setActionRevalidatedHeader(headers, kind) {
 	if (kind === ACTION_DID_NOT_REVALIDATE) return;
 	headers.set(ACTION_REVALIDATED_HEADER, JSON.stringify(kind));
@@ -31,6 +45,67 @@ function resolveActionRevalidationKind(hasModifiedCookies) {
 	if (hasModifiedCookies) return ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC;
 	return revalidationKind;
 }
+function cloneActionRedirectHeaders(requestHeaders) {
+	const headers = new Headers(requestHeaders);
+	for (const header of ACTION_REDIRECT_RENDER_STRIPPED_HEADERS) headers.delete(header);
+	return headers;
+}
+function readSetCookieNameValue(setCookie) {
+	const equalsIndex = setCookie.indexOf("=");
+	if (equalsIndex <= 0) return null;
+	const name = setCookie.slice(0, equalsIndex).trim();
+	const valueEnd = setCookie.indexOf(";", equalsIndex + 1);
+	return {
+		name,
+		value: setCookie.slice(equalsIndex + 1, valueEnd === -1 ? void 0 : valueEnd)
+	};
+}
+function isExpiredSetCookie(setCookie) {
+	return /(?:^|;\s*)max-age=0(?:;|$)/i.test(setCookie) || /(?:^|;\s*)expires=Thu,\s*0?1[\s-]+Jan[\s-]+1970/i.test(setCookie);
+}
+function applySetCookieMutationsToRequestCookieHeader(cookieHeader, setCookies) {
+	const cookies = /* @__PURE__ */ new Map();
+	if (cookieHeader) for (const part of cookieHeader.split(";")) {
+		const trimmed = part.trim();
+		if (!trimmed) continue;
+		const equalsIndex = trimmed.indexOf("=");
+		if (equalsIndex <= 0) continue;
+		cookies.set(trimmed.slice(0, equalsIndex), trimmed.slice(equalsIndex + 1));
+	}
+	for (const setCookie of setCookies) {
+		const entry = readSetCookieNameValue(setCookie);
+		if (!entry) continue;
+		if (isExpiredSetCookie(setCookie)) cookies.delete(entry.name);
+		else cookies.set(entry.name, entry.value);
+	}
+	return cookies.size === 0 ? null : [...cookies].map(([name, value]) => `${name}=${value}`).join("; ");
+}
+function createActionRedirectRenderRequest(options) {
+	const headers = cloneActionRedirectHeaders(options.request.headers);
+	const cookieHeader = applySetCookieMutationsToRequestCookieHeader(headers.get("cookie"), options.pendingCookies);
+	if (cookieHeader === null) headers.delete("cookie");
+	else headers.set("cookie", cookieHeader);
+	return new Request(options.url, {
+		headers,
+		method: "GET"
+	});
+}
+function withoutRscBodyHeaders(headers) {
+	const nextHeaders = new Headers(headers);
+	nextHeaders.delete("Content-Type");
+	nextHeaders.delete("Vary");
+	return nextHeaders;
+}
+function isReadableStreamBody(body) {
+	return typeof ReadableStream !== "undefined" && body instanceof ReadableStream;
+}
+function createServerActionRscResponse(body, init, clearRequestContext) {
+	if (!isReadableStreamBody(body)) {
+		clearRequestContext();
+		return new Response(body, init);
+	}
+	return new Response(deferUntilStreamConsumed(body, clearRequestContext), init);
+}
 function isRequestBodyTooLarge(error) {
 	return error instanceof Error && error.message === "Request body too large";
 }
@@ -147,6 +222,53 @@ function applyActionRedirectBasePath(url, basePath) {
 	const suffix = splitAt === -1 ? "" : url.slice(splitAt);
 	return `${addBasePathToPathname(pathname, basePath)}${suffix}`;
 }
+function buildServerActionPageTags(route, pathname) {
+	return buildPageCacheTags(pathname, [], [...route.routeSegments ?? []], "page");
+}
+function resolveInternalActionRedirectTarget(redirectUrl, requestUrl, basePath) {
+	if (isExternalUrl(redirectUrl)) {
+		const requestOrigin = new URL(requestUrl).origin;
+		const parsed = new URL(redirectUrl);
+		if (parsed.origin !== requestOrigin) return null;
+		if (basePath && !hasBasePath(parsed.pathname, basePath)) return null;
+		return parsed;
+	}
+	let resolvedBase = requestUrl;
+	if (!redirectUrl.startsWith("/") && !/^[a-z]+:/i.test(redirectUrl)) {
+		const parsedRequestUrl = new URL(requestUrl);
+		let pathname = parsedRequestUrl.pathname;
+		if (!pathname.endsWith("/")) pathname = pathname + "/";
+		resolvedBase = `${parsedRequestUrl.origin}${pathname}${parsedRequestUrl.search}`;
+	}
+	return new URL(redirectUrl, resolvedBase);
+}
+function isAncestorRouteRedirect(targetPathname, currentPathname) {
+	return targetPathname !== "/" && currentPathname.startsWith(`${targetPathname}/`);
+}
+function isStaleChildSiblingRouteRedirect(targetPathname, currentPathname) {
+	const targetSegments = splitPathSegments(targetPathname);
+	const currentSegments = splitPathSegments(currentPathname);
+	if (targetSegments.length === 0 || currentSegments.length <= targetSegments.length) return false;
+	let commonPrefixLength = 0;
+	const maxPrefixLength = Math.min(targetSegments.length, currentSegments.length);
+	while (commonPrefixLength < maxPrefixLength && targetSegments[commonPrefixLength] === currentSegments[commonPrefixLength]) commonPrefixLength++;
+	return commonPrefixLength > 0 && commonPrefixLength < targetSegments.length;
+}
+function normalizeRuntime(runtime) {
+	if (runtime === "edge" || runtime === "experimental-edge") return "edge";
+	return "nodejs";
+}
+function shouldUseForwardedActionRedirectStatus(options) {
+	if (options.actionWasForwarded) return true;
+	if (isAncestorRouteRedirect(options.targetPathname, options.currentPathname)) return true;
+	if (isStaleChildSiblingRouteRedirect(options.targetPathname, options.currentPathname)) return true;
+	if (!options.currentRoute || !options.resolveRouteRuntime) return false;
+	return normalizeRuntime(options.resolveRouteRuntime(options.currentRoute)) !== normalizeRuntime(options.resolveRouteRuntime(options.targetRoute));
+}
+function canRenderActionRedirectTarget(route) {
+	if ("routeHandler" in route && route.routeHandler) return false;
+	return route.page !== null && route.page !== void 0;
+}
 function getActionHttpFallbackStatus(error) {
 	const digest = getNextErrorDigest(error);
 	if (!digest) return null;
@@ -180,10 +302,6 @@ function isProgressiveServerActionRequest(request, contentType, actionId) {
 }
 async function handleProgressiveServerActionRequest(options) {
 	if (!isProgressiveServerActionRequest(options.request, options.contentType, options.actionId)) return null;
-	if (options.request.headers.get("x-action-forwarded")) return createActionNotFoundResponse(null, {
-		clearRequestContext: options.clearRequestContext,
-		getAndClearPendingCookies: options.getAndClearPendingCookies
-	});
 	const csrfResponse = validateCsrfOrigin(options.request, options.allowedOrigins);
 	if (csrfResponse) return csrfResponse;
 	if (parseInt(options.request.headers.get("content-length") || "0", 10) > options.maxActionBodySize) {
@@ -295,10 +413,6 @@ async function handleProgressiveServerActionRequest(options) {
 }
 async function handleServerActionRscRequest(options) {
 	if (options.request.method.toUpperCase() !== "POST" || !options.actionId) return null;
-	if (options.request.headers.get("x-action-forwarded")) return createActionNotFoundResponse(options.actionId, {
-		clearRequestContext: options.clearRequestContext,
-		getAndClearPendingCookies: options.getAndClearPendingCookies
-	});
 	const csrfResponse = validateCsrfOrigin(options.request, options.allowedOrigins);
 	if (csrfResponse) return csrfResponse;
 	if (parseInt(options.request.headers.get("content-length") || "0", 10) > options.maxActionBodySize) {
@@ -340,6 +454,7 @@ async function handleServerActionRscRequest(options) {
 		let returnValue;
 		let actionRedirect = null;
 		let actionStatus = 200;
+		const actionWasForwarded = Boolean(options.request.headers.get(ACTION_FORWARDED_HEADER));
 		const previousHeadersPhase = options.setHeadersAccessPhase("action");
 		try {
 			try {
@@ -378,7 +493,6 @@ async function handleServerActionRscRequest(options) {
 			const actionPendingCookies = dedupePendingCookies(options.getAndClearPendingCookies());
 			const actionDraftCookie = options.getDraftModeCookieHeader();
 			const actionRevalidationKind = resolveActionRevalidationKind(actionPendingCookies.length > 0 || Boolean(actionDraftCookie));
-			options.clearRequestContext();
 			const redirectHeaders = new Headers({
 				"Content-Type": VINEXT_RSC_CONTENT_TYPE,
 				Vary: VINEXT_RSC_VARY_HEADER
@@ -386,27 +500,85 @@ async function handleServerActionRscRequest(options) {
 			applyEdgeRuntimeHeader(redirectHeaders, options.isEdgeRuntime);
 			mergeMiddlewareResponseHeaders(redirectHeaders, options.middlewareHeaders);
 			applyRscCompatibilityIdHeader(redirectHeaders);
-			redirectHeaders.set(ACTION_REDIRECT_HEADER, applyActionRedirectBasePath(actionRedirect.url, options.basePath ?? ""));
+			const actionRedirectUrl = applyActionRedirectBasePath(actionRedirect.url, options.basePath ?? "");
+			redirectHeaders.set(ACTION_REDIRECT_HEADER, actionRedirectUrl);
 			redirectHeaders.set(ACTION_REDIRECT_TYPE_HEADER, actionRedirect.type);
 			redirectHeaders.set(ACTION_REDIRECT_STATUS_HEADER, String(actionRedirect.status));
 			for (const cookie of actionPendingCookies) redirectHeaders.append("Set-Cookie", cookie);
 			if (actionDraftCookie) redirectHeaders.append("Set-Cookie", actionDraftCookie);
 			setActionRevalidatedHeader(redirectHeaders, actionRevalidationKind);
-			return new Response("", {
-				status: 200,
-				headers: redirectHeaders
+			const redirectTarget = resolveInternalActionRedirectTarget(actionRedirectUrl, options.request.url, options.basePath ?? "");
+			if (!redirectTarget) {
+				options.clearRequestContext();
+				return new Response(null, {
+					status: 303,
+					headers: withoutRscBodyHeaders(redirectHeaders)
+				});
+			}
+			const targetPathname = stripBasePath(redirectTarget.pathname, options.basePath ?? "");
+			const targetMatch = options.matchRoute(targetPathname);
+			if (targetMatch) await options.ensureRouteLoaded?.(targetMatch.route);
+			if (!targetMatch || !canRenderActionRedirectTarget(targetMatch.route)) {
+				options.clearRequestContext();
+				return new Response(null, {
+					status: 303,
+					headers: withoutRscBodyHeaders(redirectHeaders)
+				});
+			}
+			const currentMatch = options.matchRoute(options.cleanPathname);
+			if (currentMatch) await options.ensureRouteLoaded?.(currentMatch.route);
+			const redirectRenderRequest = createActionRedirectRenderRequest({
+				pendingCookies: [...actionPendingCookies, ...actionDraftCookie ? [actionDraftCookie] : []],
+				request: options.request,
+				url: redirectTarget
+			});
+			setHeadersContext(headersContextFromRequest(redirectRenderRequest));
+			options.setNavigationContext({
+				pathname: targetPathname,
+				searchParams: redirectTarget.searchParams,
+				params: targetMatch.params
 			});
+			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(targetMatch.route) ?? null);
+			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
+			}), {
+				status: shouldUseForwardedActionRedirectStatus({
+					actionWasForwarded,
+					currentPathname: options.cleanPathname,
+					currentRoute: currentMatch?.route ?? null,
+					resolveRouteRuntime: options.resolveRouteRuntime,
+					targetPathname,
+					targetRoute: targetMatch.route
+				}) ? 200 : 303,
+				headers: redirectHeaders
+			}, options.clearRequestContext);
 		}
 		const actionPendingCookies = dedupePendingCookies(options.getAndClearPendingCookies());
 		const actionDraftCookie = options.getDraftModeCookieHeader();
 		const actionRevalidationKind = resolveActionRevalidationKind(actionPendingCookies.length > 0 || Boolean(actionDraftCookie));
-		if (actionRevalidationKind === ACTION_DID_NOT_REVALIDATE) {
+		if (actionWasForwarded || actionStatus === 200 && actionRevalidationKind === ACTION_DID_NOT_REVALIDATE) {
 			const onRenderError = options.createRscOnErrorHandler(options.request, options.cleanPathname, options.cleanPathname);
 			const rscStream = await options.renderToReadableStream({ returnValue }, {
 				temporaryReferences,
 				onError: onRenderError
 			});
-			options.clearRequestContext();
 			const actionHeaders = new Headers({
 				"Content-Type": VINEXT_RSC_CONTENT_TYPE,
 				Vary: VINEXT_RSC_VARY_HEADER
@@ -414,10 +586,13 @@ async function handleServerActionRscRequest(options) {
 			applyEdgeRuntimeHeader(actionHeaders, options.isEdgeRuntime);
 			mergeMiddlewareResponseHeaders(actionHeaders, options.middlewareHeaders);
 			applyRscCompatibilityIdHeader(actionHeaders);
-			return new Response(rscStream, {
+			for (const cookie of actionPendingCookies) actionHeaders.append("Set-Cookie", cookie);
+			if (actionDraftCookie) actionHeaders.append("Set-Cookie", actionDraftCookie);
+			setActionRevalidatedHeader(actionHeaders, actionRevalidationKind);
+			return createServerActionRscResponse(rscStream, {
 				status: options.middlewareStatus ?? actionStatus,
 				headers: actionHeaders
-			});
+			}, options.clearRequestContext);
 		}
 		const match = options.matchRoute(options.cleanPathname);
 		let element;
@@ -439,7 +614,9 @@ async function handleServerActionRscRequest(options) {
 				searchParams: options.searchParams,
 				params: actionRerenderTarget.navigationParams
 			});
+			await options.ensureRouteLoaded?.(actionRerenderTarget.route);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(actionRerenderTarget.route) ?? null);
+			setCurrentFetchSoftTags(buildServerActionPageTags(actionRerenderTarget.route, options.cleanPathname));
 			element = options.buildPageElement({
 				cleanPathname: options.cleanPathname,
 				interceptOpts: actionRerenderTarget.interceptOpts,
@@ -472,10 +649,10 @@ async function handleServerActionRscRequest(options) {
 		mergeMiddlewareResponseHeaders(actionHeaders, options.middlewareHeaders);
 		applyRscCompatibilityIdHeader(actionHeaders);
 		setActionRevalidatedHeader(actionHeaders, actionRevalidationKind);
-		const actionResponse = new Response(rscStream, {
+		const actionResponse = createServerActionRscResponse(rscStream, {
 			status: options.middlewareStatus ?? actionStatus,
 			headers: actionHeaders
-		});
+		}, options.clearRequestContext);
 		if (actionPendingCookies.length > 0 || actionDraftCookie) {
 			for (const cookie of actionPendingCookies) actionResponse.headers.append("Set-Cookie", cookie);
 			if (actionDraftCookie) actionResponse.headers.append("Set-Cookie", actionDraftCookie);
@@ -494,5 +671,3 @@ async function handleServerActionRscRequest(options) {
 }
 //#endregion
 export { applyActionRedirectBasePath, handleProgressiveServerActionRequest, handleServerActionRscRequest, isProgressiveServerActionRequest, readActionBodyWithLimit, readActionFormDataWithLimit };
-
-//# sourceMappingURL=app-server-action-execution.js.map

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

@@ -1,5 +1,6 @@
 import { NavigationContext } from "../shims/navigation.js";
 import { RootParams } from "../shims/root-params.js";
+import { AppSsrRenderResult } from "./app-page-stream.js";
 import { ReactFormState } from "react-dom/client";
 
 //#region src/server/app-ssr-entry.d.ts
@@ -29,15 +30,15 @@ declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navContext: Na
    * SSR head. Undefined or empty disables emission entirely.
    */
   clientTraceMetadata?: readonly string[];
-  rootParams?: RootParams;
+  rootParams?: RootParams; /** Dev-only: original server error to surface in the browser overlay. */
+  initialDevServerError?: unknown;
   /** When true, wait for the full React tree (including Suspense boundaries)
    *  to resolve before returning the HTML stream. Used for static prerender
    *  and ISR cache writes to avoid caching fallback content. */
   waitForAllReady?: boolean;
-}): Promise<ReadableStream<Uint8Array>>;
+}): Promise<AppSsrRenderResult>;
 declare const _default: {
   fetch(request: Request): Promise<Response>;
 };
 //#endregion
-export { FontData, FontPreload, _default as default, handleSsr };
-//# sourceMappingURL=app-ssr-entry.d.ts.map
+export { FontData, FontPreload, _default as default, handleSsr };

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

@@ -4,19 +4,21 @@ import { isOpenRedirectShaped } from "./request-pipeline.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
-import { ServerInsertedHTMLContext, appRouterInstance, clearServerInsertedHTML, renderServerInsertedHTML, setNavigationContext, useServerInsertedHTML } from "../shims/navigation.js";
+import { ServerInsertedHTMLContext, appRouterInstance, clearServerInsertedHTML, getBfcacheIdMapContext, renderServerInsertedHTML, setNavigationContext, useServerInsertedHTML } from "../shims/navigation.js";
 import { runWithNavigationContext } from "../shims/navigation-state.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, safeJsonStringify } from "./html.js";
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
-import { ElementsContext, Slot } from "../shims/slot.js";
+import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
+import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform } from "./app-ssr-stream.js";
+import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
+import { runWithRootParamsScope } from "../shims/root-params.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-browser-state.js";
 import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
 import { createClientReferencePreloader } from "./app-client-reference-preloader.js";
 import { deferUntilStreamConsumed } from "./app-page-stream.js";
-import { runWithRootParamsScope } from "../shims/root-params.js";
-import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
-import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
+import { createInitialDevServerErrorScript } from "./dev-initial-server-error.js";
 import { Fragment, createElement, use } from "react";
 import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server.edge";
 import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
@@ -33,6 +35,7 @@ const clientReferencePreloader = createClientReferencePreloader({
 		if (process.env.NODE_ENV !== "production") console.warn("[vinext] failed to preload client ref:", id, error);
 	}
 });
+const BfcacheIdMapContext = getBfcacheIdMapContext();
 function ssrErrorDigest(input) {
 	let hash = 5381;
 	for (let i = input.length - 1; i >= 0; i--) hash = hash * 33 ^ input.charCodeAt(i);
@@ -117,15 +120,20 @@ function buildModulePreloadHtml(bootstrapModuleUrl, nonce) {
 }
 function buildHeadInjectionHtml(navContext, bootstrapModuleUrl, formState, insertedHTML, fontHTML, scriptNonce) {
 	const navPayload = {
-		pathname: navContext?.pathname ?? "/",
-		searchParams: navContext?.searchParams ? [...navContext.searchParams.entries()] : []
+		pathname: navContext.pathname,
+		searchParams: [...navContext.searchParams.entries()]
 	};
-	return createInlineScriptTag(createNavigationRuntimeRscMetadataScript(navContext?.params ?? {}, navPayload), scriptNonce) + (formState === null ? "" : createInlineScriptTag("self[" + safeJsonStringify(RSC_FORM_STATE_GLOBAL) + "]=" + safeJsonStringify(formState), scriptNonce)) + buildModulePreloadHtml(bootstrapModuleUrl, scriptNonce) + insertedHTML + fontHTML;
+	return createInlineScriptTag(createNavigationRuntimeRscMetadataScript(navContext.params, navPayload), scriptNonce) + (formState === null ? "" : createInlineScriptTag("self[" + safeJsonStringify(RSC_FORM_STATE_GLOBAL) + "]=" + safeJsonStringify(formState), scriptNonce)) + buildModulePreloadHtml(bootstrapModuleUrl, scriptNonce) + insertedHTML + fontHTML;
+}
+function requireNavigationContext(navContext) {
+	if (!navContext) throw new Error("App SSR requires navigation context for BFCache state keys");
+	return navContext;
 }
 async function handleSsr(rscStream, navContext, fontData, options) {
 	return runWithNavigationContext(async () => {
+		const ssrNavigationContext = requireNavigationContext(navContext);
 		await clientReferencePreloader.preload();
-		if (navContext) setNavigationContext(navContext);
+		setNavigationContext(ssrNavigationContext);
 		clearServerInsertedHTML();
 		const cleanup = () => {
 			setNavigationContext(null);
@@ -150,7 +158,12 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					const wireElements = use(flightRoot);
 					const elements = AppElementsWire.decode(wireElements);
 					const metadata = AppElementsWire.readMetadata(elements);
-					return createElement(ElementsContext.Provider, { value: elements }, createElement(Slot, { id: metadata.routeId }));
+					const routeTree = createElement(ElementsContext.Provider, { value: elements }, createElement(Slot, { id: metadata.routeId }));
+					const stateKeyTree = createElement(BfcacheStateKeyMapContext.Provider, { value: createBfcacheSegmentStateKeyMap({
+						elements,
+						pathname: ssrNavigationContext.pathname
+					}) }, routeTree);
+					return BfcacheIdMapContext ? createElement(BfcacheIdMapContext.Provider, { value: createInitialBfcacheIdMap(elements) }, stateKeyTree) : stateKeyTree;
 				}
 				const flightRootElement = createElement(VinextFlightRoot);
 				const root = AppRouterContext ? createElement(AppRouterContext.Provider, { value: appRouterInstance }, flightRootElement) : flightRootElement;
@@ -172,7 +185,6 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 						if (process.env.NODE_ENV === "production" && error) return ssrErrorDigest(getErrorMessage(error) + (error instanceof Error ? error.stack ?? "" : ""));
 					}
 				});
-				if (options?.waitForAllReady === true) await htmlStream.allReady;
 				const inlineCssManifest = globalThis.__VINEXT_INLINE_CSS__;
 				const fontStyles = fontData?.styles ?? [];
 				const mergeFontStylesIntoInlineCss = fontStyles.length > 0 && hasInlineCssManifest(inlineCssManifest);
@@ -188,12 +200,18 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				const getInsertedHTML = () => {
 					const insertedHTML = renderInsertedHtml(renderServerInsertedHTML());
 					const errorMetaHTML = errorMetaRenderer.flush();
+					const initialDevServerErrorHTML = createInitialDevServerErrorScript(options?.initialDevServerError, options?.scriptNonce);
 					if (didInjectHeadHTML) return insertedHTML + errorMetaHTML;
 					didInjectHeadHTML = true;
-					return buildHeadInjectionHtml(navContext, bootstrapModuleUrl, options?.formState ?? null, insertedHTML + errorMetaHTML + getTraceMetaHTML(), fontHTML, options?.scriptNonce);
+					return buildHeadInjectionHtml(ssrNavigationContext, bootstrapModuleUrl, options?.formState ?? null, insertedHTML + errorMetaHTML + getTraceMetaHTML() + initialDevServerErrorHTML, fontHTML, options?.scriptNonce);
 				};
 				const getBeforeInteractiveHeadHTML = () => renderBeforeInteractiveInlineScripts(beforeInteractiveInlineScripts);
-				return deferUntilStreamConsumed(htmlStream.pipeThrough(createTickBufferedTransform(rscEmbed, getInsertedHTML, getBeforeInteractiveHeadHTML, inlineCssManifest, inlineCssFontStyles, inlineCssFontStyleFallbackHTML, options?.scriptNonce)), cleanup);
+				if (options?.waitForAllReady === true) await htmlStream.allReady;
+				return {
+					htmlStream: deferUntilStreamConsumed(htmlStream.pipeThrough(createTickBufferedTransform(rscEmbed, getInsertedHTML, getBeforeInteractiveHeadHTML, inlineCssManifest, inlineCssFontStyles, inlineCssFontStyleFallbackHTML, options?.scriptNonce)), cleanup),
+					metadataReady: Promise.resolve(),
+					capturedRscData: options?.capturedRscDataRef?.value ?? null
+				};
 			} catch (error) {
 				cleanup();
 				throw error;
@@ -210,5 +228,3 @@ var app_ssr_entry_default = { async fetch(request) {
 } };
 //#endregion
 export { app_ssr_entry_default as default, handleSsr };
-
-//# sourceMappingURL=app-ssr-entry.js.map

package/dist/server/app-ssr-error-meta.d.ts

@@ -10,5 +10,4 @@ type SsrErrorMetaRenderer = {
 declare function renderSsrErrorMetaTags(errors: readonly unknown[], options?: SsrErrorMetaRenderOptions): string;
 declare function createSsrErrorMetaRenderer(options?: SsrErrorMetaRenderOptions): SsrErrorMetaRenderer;
 //#endregion
-export { createSsrErrorMetaRenderer, renderSsrErrorMetaTags };
-//# sourceMappingURL=app-ssr-error-meta.d.ts.map
+export { createSsrErrorMetaRenderer, renderSsrErrorMetaTags };

package/dist/server/app-ssr-error-meta.js

@@ -46,5 +46,3 @@ function createSsrErrorMetaRenderer(options = {}) {
 }
 //#endregion
 export { createSsrErrorMetaRenderer, renderSsrErrorMetaTags };
-
-//# sourceMappingURL=app-ssr-error-meta.js.map

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

@@ -57,5 +57,4 @@ declare function fixPreloadAs(html: string): string;
  */
 declare function createTickBufferedTransform(rscEmbed: RscEmbedTransform, injectHTML?: HtmlInsertion, injectAfterHeadOpenHTML?: HtmlInsertion, inlineCssManifest?: InlineCssManifest, inlineCssPrependCss?: string, inlineCssPrependFallbackHTML?: string, inlineCssScriptNonce?: string): TransformStream<Uint8Array, Uint8Array>;
 //#endregion
-export { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, fixFlightHints, fixPreloadAs, navigationRuntimeRscBootstrapExpression };
-//# sourceMappingURL=app-ssr-stream.d.ts.map
+export { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, fixFlightHints, fixPreloadAs, navigationRuntimeRscBootstrapExpression };