PR #84525: Fix/action forward loop guard

• Repository: vercel/next.js
• Author: LiamBoz
• State: open | merged: False
• Link: https://github.com/vercel/next.js/pull/84525

Description (problem / solution / changelog)

What?

Fixes #84504

Add a minimal loop-detection guard to createForwardedActionResponse so a Server Action request that has already been forwarded (marked by x-action-forwarded=1) is not forwarded again. Instead, we return early (no second forward).

• File: packages/next/src/server/app-render/action-handler.ts
• Behavior change: if x-action-forwarded=1 is present on the incoming request, return from createForwardedActionResponse without forwarding again.

Why?

In apps that use Middleware rewrites, a forwarded Server Action request can be rewritten to a path that triggers forwarding again, causing an infinite loop (e.g. /rewrite/other → /rewrite/... → /rewrite/rewrite/... → …). This leads to repeated logs and a server action that never resolves.

This guard breaks the cycle with very low risk by only affecting requests that were already forwarded once.

• Repro repo: https://github.com/blairmcalpine/forwarded-server-action-request-loop-repro
• Steps:
  1. npm i && npm run dev
  2. Visit http://localhost:3000
  3. Click Run action, then quickly (<500ms) click Navigate to other page
  4. Before this change: infinite loop/log spam; action never resolves.
  5. After this change: no loop; request is not re-forwarded again.

How?

At the start of createForwardedActionResponse, inspect the incoming headers:

• If x-action-forwarded=1 is present → return (do not forward again).
• Otherwise, proceed as before and set x-action-forwarded=1 on the outgoing forwarded request.

Works in both Node and Edge:

• If req.headers is already a Headers (Edge), use it.
• Otherwise adapt Node headers via HeadersAdapter.

Test Plan

Manual (using the public repro)

• With this patch built and packed into the repro app:
  • Trigger the fast Run action → Navigate sequence.
  • Confirm:
    • No repeated /rewrite/... requests or log spam.
    • The page no longer gets stuck due to an infinite forwarding loop.

Notes: This PR intentionally focuses on loop prevention. A broader follow-up could make forwarded requests mirror the pre-rewrite target to ensure resolution semantics remain identical under rewrites. That would be a separate change.

Risk

Low:

• Only affects requests that already bear x-action-forwarded=1.
• Does not change the initial legitimate forward.
• Keeps all other server action behavior intact.

For Contributors Checklist

• Bug fix
• Related issue linked (Fixes #84504)
• Repro steps included (public repo)
• Ran pnpm prettier-fix locally
• Tests: this is a minimal guard; happy to add a small e2e that simulates a rewrite + quick navigation if maintainers prefer (guidance welcome)

Changed files

• packages/next/src/server/app-render/action-handler.ts (modified, +14/-0)

PR #92053: fix: prevent infinite request loop when forwarding server actions with middleware rewrites

• Repository: vercel/next.js
• Author: claygeo
• State: open | merged: False
• Link: https://github.com/vercel/next.js/pull/92053

Description (problem / solution / changelog)

Problem

Fixes #84504

When a server action fires right before navigation, Next.js forwards the action to the correct worker via createForwardedActionResponse. If middleware applies a rewrite to the forwarded request, the rewritten URL arrives at a worker that also wants to forward, creating an infinite request loop that never resolves.

Root Cause

In action-handler.ts, the forwarding guard at line 713 checks if (actionId) but does not check whether the action was already forwarded:

const actionWasForwarded = Boolean(req.headers['x-action-forwarded'])  // line 711: READ but not used as guard

if (actionId) {  // line 713: missing !actionWasForwarded check
  const forwardedWorker = selectWorkerForForwarding(actionId, page)
  if (forwardedWorker) {
    return createForwardedActionResponse(...)  // forwards again → infinite loop
  }
}

The x-action-forwarded header is already set on outgoing forwarded requests (createForwardedActionResponse, line 221) and read on incoming requests (line 711). The loop detection mechanism exists, it's just not wired into the forwarding guard.

Fix

Add !actionWasForwarded to the forwarding condition:

if (actionId && !actionWasForwarded) {

If an action has already been forwarded once (header present), skip the forwarding logic entirely. The action will be handled by the current worker instead of bouncing infinitely between workers.

5 lines changed in 1 file.

Note on PR #84525

PR #84525 addresses the same issue but has been abandoned for 6 months with zero reviews. This PR takes the same conceptual approach (check x-action-forwarded header) with a cleaner implementation at the caller level rather than inside createForwardedActionResponse.

Changed files

• packages/next/src/server/app-render/action-handler.ts (modified, +35/-11)