transform: async-step render state machines lose per-activation identity at scale — Next.js dynamic RSC deadlock (last 3/8 SSR routes)

[proggeramlug]

Summary

After #5854 (c7feba788) the CPS async→generator transform lowers the entire Next.js App Router render chain to suspending async-step state machines. At scale, those machines lose per-activation identity, so the render forms a promise cycle that never settles and the request-time dynamic RSC routes hang.

With the runtime fixes in #5932 the static + API routes are byte-identical vs node (5/8); the 3 request-time dynamic renders — /posts/[id], /fetcher, /plain — still hang (0 bytes, no throw). This issue tracks the remaining transform-side fix needed for 8/8.

This is the follow-up called out in #5880 / #5932 and is separate from the runtime promise-machinery bugs those PRs fixed. It sits on top of #5854's transform (worktree/branch async-transform-cps).

Ground-truth diagnosis (perturbation-proof)

Measured on the full-transform build (current main + #5932) with a global-registry background stuck-machine dumper (see toolkit below — env-gated, does not perturb timing):

• The /plain render parks with ~18 async-step machines, every awaited promise Pending with a STEP_THUNK reaction registered.
• Await-graph: 6 EXTERNAL/orphan promises (React-internal new Promise((resolve)=>…) owned by no async-step machine) + 6 await-DONE-machine + chained.
• [PUMP] has_work=1 microtasks=0 timer=-1 interval=-1 callback_timer=-1 → event loop is empty (the only "work" is the idle listening HTTP server via aux_has_active()).
• AbortController.abort() never called, no abort listeners registered → the render parks before the params/dynamicIO-abort phase; the orphans are React-core promises, not makeHangingPromise.

Named frames (func_ptr→atos on a PERRY_DEBUG_SYMBOLS build)

The parked call-chain is clean:

start-server → next-server → router-server → base-server
  → app-page-turbo runtime (React server renderer)  __4057 / __4063 / __4066 / __4256
    → app-page template (render callbacks)           __132 / __147 / __150

The 3 orphan-promise root awaiters are the app-page template render callbacks (__132, __150) and the React renderer (__4057). React's server renderer awaits internal new Promises whose resolvers live in React's own work loop — which is itself in the parked set (__4063/__4066) → self-referential deadlock. In node this never happens because React's prerender yields the shell early; under the full transform on Perry it does not.

Root cause (localized across prior diagnostic passes)

The render's simultaneously-active state machines collide on per-activation identity — a shared boxed state-var (state/sent/done) and/or step closure reused across two live activations via the capture-value-keyed singleton cache (the #1029 / #5143 PreallocateBoxes / compute_max_func_id family). A machine's continuation then settles the wrong activation's promise, orphaning the real awaiter → the cycle.

• Disabling the step-closure singleton alone (PERRY_NO_CAPTURED_SINGLETON) does not fix it → the collision is the boxed state-var box, not (only) the step closure.
• It is scale-dependent: two disjoint ~367-module subsets each break curl /; a 366-module subset works. No minimal repro exists — the interaction needs the bundle's simultaneous-machine volume.

Fix target

Make the transformed generator state machines' boxed state-var (and step closure) per-activation-distinct in transform_generator_function_with_extra_captures (perry-transform) + the box/closure singleton cache keying — i.e. extend the #1029 PreallocateBoxes distinctness to the async-step machines the CPS transform now produces at Next.js scale. This is transform territory (the async-transform-cps area), which is why it's handed here rather than duplicated in a runtime PR.

Reproduction

Next.js 16 App Router standalone build (output: 'standalone', dynamicIO/cacheComponents on), routes: static (/, /about, /counter), API (/api/hello GET+POST), dynamic (/posts/[id] awaits params; /fetcher force-dynamic in-process fetch; /plain force-dynamic static JSX). Compile server.js with perry (+ #5932). Static + API = byte-identical vs node v26; the 3 dynamic routes hang.

Diagnostic toolkit (for whoever picks this up)

A PERRY_STUCK_DUMP=1-gated, perturbation-proof toolkit (global Mutex<HashMap> of active machines + a 6s background dumper thread that classifies awaited values by NaN-tag without deref, plus [PUMP]/await-graph/[DIVERGE]/[MISRESOLVE]) cracked the mechanism where every env/JS probe perturbed it. It was stripped from #5932 for shipping but is fully specified in the diagnosis and quick to re-add to async_step.rs. func_ptr→atos -l <vmmap __TEXT base> on a PERRY_DEBUG_SYMBOLS=1 compile names the stuck JS closures off-stack (SIGBT can't — the machines are suspended).

References

• Next.js standalone: deferred-require binding captured by-value (as unresolved thunk) by a class constructor → 'undefined is not a constructor' #5437 — Next.js standalone tracking
• transform(async): CPS async class methods, capturing-closure fns, and nested async closures #5854 (c7feba788) — the CPS transform this sits on; async-transform-cps branch
• fix(runtime): #5437 — async-step result-promise + reaction preservation restore Next.js SSR statics (0/8→5/8) #5932 — runtime promise-machinery fixes (0/8 → 5/8); the foundation this builds on
• fix(#5437): Next.js 16 app-router SSR — boot + statics/API (5/8 routes byte-identical) #5880 — earlier runtime fixes; originally flagged this follow-up

[proggeramlug]

Investigation + fixes: PR #5988. Summary of what changed relative to this issue's framing:

The per-activation-identity theory is refuted by direct measurement. I re-added the perturbation-proof toolkit (this time with a live-activation collision detector in js_async_first_call: it fires if a step-closure pointer re-enters first_call while a prior activation is live). On the full /plain repro — same 18 parked machines, same atos-named frame set as in this issue — it fired zero times; every machine had exactly one first_call. Statically consistent: a step closure's singleton-cache key always contains ≥4 per-activation box pointers, and boxes are never freed or recycled, so cross-activation cache hits can't happen. Also refuted: GC-evacuation staleness (PERRY_GEN_GC=0 still hangs) and LocalId-collision-into-non-box-slot (no PERRY_DEBUG box warnings).

The real roots were runtime promise-machinery bugs, found by extending the await-graph walker with then-chain/adoption edges + settlement annotation:

1. js_promise_resolve_with_promise's slow path unconditionally nulled inner.next, severing a prior dependent's fast-path adoption edge whenever a second dependent adopted the same shared inner promise. The render chain adopts shared React work promises in exactly this shape — that's the scale dependence (and why every single-machine probe came back clean). Fixing it: 18 parked machines → 2.
2. The async-step resume thunks discarded a resumed step's catch-arm return (return Promise.reject(e)), so a throw after a pending await never rejected the machine's result promise — awaiters hung instead of catching. Fixing it: 2 parked machines → 0; the async-step graph fully settles and real errors propagate.

Both now have minimal repros (in the PR as integration tests), dissolving the "no minimal repro exists" premise — the two-adopters shape just had to be known.

The transform-side hardening this issue asked for also got one real improvement: compute_max_local_id/compute_max_func_id never scanned outer param defaults (a default value can carry closures with fresh ids) — folded in with unit tests, though it wasn't the live root here.

What remains for 8/8 (different wall, needs its own issue): the dynamic routes still return no bytes, but there is no deadlock left — no parked machines, all promises settle, rejections propagate. The request dies silently after two expected (caught-in-node) ENOENT throws for optional manifests (subresource-integrity-manifest.json, dynamic-css-manifest). The divergence is now in the render/error-recovery flow with a clean async graph. Toolkit to replay: branch fix/async-step-per-activation-identity-5941 (PERRY_STUCK_DUMP=1, plus touch /tmp/perry-arm-throw before the request to log request-window throws/rejections).

Also observed while validating (unrelated to this work, fresh regression in the 2026-07-04 main window): GET /api/hello now segfaults the compiled server — it was byte-identical at the #5932 validation the same morning. Filing separately.

[proggeramlug]

Closing: the deadlock class this issue tracked is eliminated by #5988 (merged as c787f6d).

• The per-activation-identity theory was refuted by direct measurement; the real roots were runtime promise-machinery bugs (shared-promise adoption severing in js_promise_resolve_with_promise, plus swallowed step-resume rejections), with minimal repros landed as integration tests. Details in the comment above.
• The residual symptom — the 3 dynamic routes still returning no bytes, now with a clean, fully-settling async graph — is a different wall and continues in nextjs: dynamic RSC render evaporates silently with a clean async graph after expected manifest ENOENTs (post-#5988 wall for 8/8) #5989.
• The unrelated GET /api/hello segfault regression observed during validation is tracked in regression: GET /api/hello segfaults the compiled Next.js standalone server (2026-07-04 main window; was byte-identical at #5932 validation) #5990.