fix: server action redirects use soft RSC navigation instead of hard reload (#654)

packages/vinext/src/entries/app-rsc-entry.ts

@@ -1877,24 +1877,113 @@ async function _handleRequest(request, __reqCtx, _mwCtx) {
       // We can't use a real HTTP redirect (the fetch would follow it automatically
       // and receive a page HTML instead of RSC stream). Instead, we return a 200
       // with x-action-redirect header that the client entry detects and handles.
+      //
+      // For same-origin routes, we pre-render the redirect target's RSC payload
+      // so the client can perform a soft RSC navigation (SPA-style) instead of
+      // a hard page reload. This matches Next.js behavior.
+      //
+      // Note: Middleware is NOT executed for the redirect target pre-render.
+      // This is a known limitation — the redirect target is rendered directly
+      // without going through the middleware pipeline.
       if (actionRedirect) {
         const actionPendingCookies = getAndClearPendingCookies();
         const actionDraftCookie = getDraftModeCookieHeader();
         setHeadersContext(null);
         setNavigationContext(null);
-        const redirectHeaders = new Headers({
+
+        // Try to pre-render the redirect target for soft RSC navigation.
+        // This is the Next.js parity fix for issue #654.
+        try {
+          const redirectUrl = new URL(actionRedirect.url, request.url);
+
+          // Only pre-render same-origin URLs. External URLs fall through to
+          // the empty-body response, which triggers a hard redirect on the client.
+          if (redirectUrl.origin === new URL(request.url).origin) {
+            const redirectMatch = matchRoute(redirectUrl.pathname);
+
+            if (redirectMatch) {
+              const { route: redirectRoute, params: redirectParams } = redirectMatch;
+
+              // Set navigation context for the redirect target
+              setNavigationContext({
+                pathname: redirectUrl.pathname,
+                searchParams: redirectUrl.searchParams,
+                params: redirectParams,
+              });
+
+              // Build and render the redirect target page
+              const redirectElement = buildPageElement(
+                redirectRoute,
+                redirectParams,
+                undefined,
+                redirectUrl.searchParams,
+              );
+
+              const redirectOnError = createRscOnErrorHandler(
+                request,
+                redirectUrl.pathname,
+                redirectRoute.pattern,
+              );
+
+              const rscStream = renderToReadableStream(
+                { root: redirectElement, returnValue },
+                { temporaryReferences, onError: redirectOnError },
+              );
+
+              // Collect cookies after rendering (same as normal action response)
+              const redirectPendingCookies = getAndClearPendingCookies();
+              const redirectDraftCookie = getDraftModeCookieHeader();
+
+              const redirectHeaders = { 
+                "Content-Type": "text/x-component; charset=utf-8", 
+                "Vary": "RSC, Accept",
+                "x-action-redirect": actionRedirect.url,
+                "x-action-redirect-type": actionRedirect.type,
+                "x-action-redirect-status": String(actionRedirect.status),
+                "x-action-rsc-prerender": "1",
+              };
+              const redirectResponse = new Response(rscStream, {
+                status: 200,
+                headers: redirectHeaders,
+              });
+
+              // Append cookies (collected after rendering, not duplicated)
+              if (redirectPendingCookies.length > 0 || redirectDraftCookie) {
+                for (const cookie of redirectPendingCookies) {
+                  redirectResponse.headers.append("Set-Cookie", cookie);
+                }
+                if (redirectDraftCookie) redirectResponse.headers.append("Set-Cookie", redirectDraftCookie);
+              }
+
+              return redirectResponse;
+            }
+          }
+        } catch (preRenderErr) {
+          // If pre-rendering fails (e.g., auth guard, missing data, unmatched route),
+          // clean up navigation context and fall through to hard redirect.
+          setNavigationContext(null);
+          console.error("[vinext] Failed to pre-render redirect target:", preRenderErr);
+        }
+
+        // Fallback: external URL or unmatched route — client will hard-navigate.
+        // Clean up navigation context before returning.
+        setNavigationContext(null);
+        const redirectHeaders = {
           "Content-Type": "text/x-component; charset=utf-8",
           "Vary": "RSC, Accept",
           "x-action-redirect": actionRedirect.url,
           "x-action-redirect-type": actionRedirect.type,
           "x-action-redirect-status": String(actionRedirect.status),
-        });
-        for (const cookie of actionPendingCookies) {
-          redirectHeaders.append("Set-Cookie", cookie);
+        };
+        const fallbackResponse = new Response(null, { status: 200, headers: redirectHeaders });
+        // Append cookies for fallback case
+        if (actionPendingCookies.length > 0 || actionDraftCookie) {
+          for (const cookie of actionPendingCookies) {
+            fallbackResponse.headers.append("Set-Cookie", cookie);
+          }
+          if (actionDraftCookie) fallbackResponse.headers.append("Set-Cookie", actionDraftCookie);
         }
-        if (actionDraftCookie) redirectHeaders.append("Set-Cookie", actionDraftCookie);
-        // Send an empty RSC-like body (client will navigate instead of parsing)
-        return new Response("", { status: 200, headers: redirectHeaders });
+        return fallbackResponse;
       }
 
       // After the action, re-render the current page so the client

packages/vinext/src/routing/file-matcher.ts

@@ -1,4 +1,6 @@
-import { glob } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { Dirent } from "node:fs";
 
 export const DEFAULT_PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js"] as const;
 
@@ -85,19 +87,80 @@ export function createValidFileMatcher(
 }
 
 /**
- * Use function-form exclude for Node < 22.14 compatibility.
+ * Use function-form exclude for Node 22.14+ compatibility.
+ * Scans for files matching stem with extensions recursively under cwd.
+ * Supports glob patterns in stem.
  */
 export async function* scanWithExtensions(
   stem: string,
   cwd: string,
   extensions: readonly string[],
   exclude?: (name: string) => boolean,
 ): AsyncGenerator<string> {
-  const pattern = buildExtensionGlob(stem, extensions);
-  for await (const file of glob(pattern, {
-    cwd,
-    ...(exclude ? { exclude } : {}),
-  })) {
-    yield file;
+  const dir = cwd;
+
+  // Check if stem contains glob patterns
+  const isGlob = stem.includes("**") || stem.includes("*");
+
+  // Extract the base name from stem (e.g., "**/page" -> "page", "page" -> "page")
+  // For "**/*", baseName will be "*" which means match all files
+  const baseName = stem.split("/").pop() || stem;
+  const matchAllFiles = baseName === "*";
+
+  async function* scanDir(currentDir: string, relativeBase: string): AsyncGenerator<string> {
+    let entries: Dirent[];
+    try {
+      entries = (await readdir(currentDir, { withFileTypes: true })) as Dirent[];
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (exclude && exclude(entry.name)) continue;
+      if (entry.name.startsWith(".")) continue;
+
+      const fullPath = join(currentDir, entry.name);
+      const relativePath = fullPath.startsWith(dir) ? fullPath.slice(dir.length + 1) : fullPath;
+
+      if (entry.isDirectory()) {
+        // Recurse into subdirectories
+        yield* scanDir(fullPath, relativePath);
+      } else if (entry.isFile()) {
+        if (matchAllFiles) {
+          // For "**/*" pattern, match any file with the given extensions
+          for (const ext of extensions) {
+            if (entry.name.endsWith(`.${ext}`)) {
+              yield relativePath;
+              break;
+            }
+          }
+        } else {
+          // Check if file matches baseName.{extension}
+          for (const ext of extensions) {
+            const expectedName = `${baseName}.${ext}`;
+            if (entry.name === expectedName) {
+              // For glob patterns like **/page, match any path ending with page.tsx
+              if (isGlob) {
+                if (relativePath.endsWith(`${baseName}.${ext}`)) {
+                  yield relativePath;
+                }
+              } else {
+                // For non-glob stems, the path should start with the stem
+                if (
+                  relativePath === `${relativeBase}.${ext}` ||
+                  relativePath.startsWith(`${relativeBase}/`) ||
+                  relativePath === `${baseName}.${ext}`
+                ) {
+                  yield relativePath;
+                }
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
   }
+
+  yield* scanDir(dir, stem);
 }

packages/vinext/src/server/app-browser-entry.ts

@@ -1,6 +1,7 @@
 /// <reference types="vite/client" />
 
 import type { ReactNode } from "react";
+import { startTransition } from "react";
 import type { Root } from "react-dom/client";
 import {
   createFromFetch,
@@ -144,11 +145,72 @@ function registerServerActionCallback(): void {
         // Fall through to hard redirect below if URL parsing fails.
       }
 
-      // Use hard redirect for all action redirects because vinext's server
-      // currently returns an empty body for redirect responses. RSC navigation
-      // requires a valid RSC payload. This is a known parity gap with Next.js,
-      // which pre-renders the redirect target's RSC payload.
+      // Check if the server pre-rendered the redirect target's RSC payload.
+      // The server sets x-action-rsc-prerender: 1 when it has pre-rendered the target.
+      // This is the fix for issue #654.
+      const hasRscPayload = fetchResponse.headers.get("x-action-rsc-prerender") === "1";
       const redirectType = fetchResponse.headers.get("x-action-redirect-type") ?? "replace";
+
+      if (hasRscPayload && fetchResponse.body) {
+        // Server pre-rendered the redirect target — apply it as a soft SPA navigation.
+        // This matches how Next.js handles action redirects internally.
+        try {
+          const result = await createFromFetch(Promise.resolve(fetchResponse), {
+            temporaryReferences,
+          });
+
+          if (isServerActionResult(result)) {
+            // Update the React tree with the redirect target's RSC payload
+            startTransition(() => {
+              getReactRoot().render(result.root);
+            });
+
+            // Update the browser URL without a reload
+            if (redirectType === "push") {
+              window.history.pushState(null, "", actionRedirect);
+            } else {
+              window.history.replaceState(null, "", actionRedirect);
+            }
+
+            // Update client-side navigation context so usePathname(), useSearchParams(),
+            // and useParams() return the correct values for the redirect target.
+            const redirectUrl = new URL(actionRedirect, window.location.origin);
+            setNavigationContext({
+              pathname: redirectUrl.pathname,
+              searchParams: redirectUrl.searchParams,
+              params: {}, // params will be populated by the RSC stream consumption
+            });
+
+            // Read params from response header (same as normal RSC navigation)
+            const paramsHeader = fetchResponse.headers.get("X-Vinext-Params");
+            if (paramsHeader) {
+              try {
+                setClientParams(JSON.parse(decodeURIComponent(paramsHeader)));
+              } catch {
+                setClientParams({});
+              }
+            } else {
+              setClientParams({});
+            }
+
+            // Handle return value if present
+            if (result.returnValue) {
+              if (!result.returnValue.ok) throw result.returnValue.data;
+              return result.returnValue.data;
+            }
+            return undefined;
+          }
+        } catch (rscParseErr) {
+          // RSC parse failed — fall through to hard redirect below.
+          console.error(
+            "[vinext] RSC navigation failed, falling back to hard redirect:",
+            rscParseErr,
+          );
+        }
+      }
+
+      // Fallback: empty body (external URL, unmatched route, or parse error).
+      // Use hard redirect to ensure the navigation still completes.
       if (redirectType === "push") {
         window.location.assign(actionRedirect);
       } else {