Uh oh!
There was an error while loading. Please reload this page.
[Flight] Add unstable_allowPartialStream option to Flight Client - #35731
Merged
Conversation
When using a partial prerender stream, i.e. a prerender that is intentionally aborted before all I/O has resolved, consumers of `createFromReadableStream` would need to keep the stream unclosed to prevent React Flight from erroring on unresolved chunks. However, some browsers (e.g. Chrome, Firefox) keep unclosed ReadableStreams with pending reads as native GC roots, retaining the entire Flight response. With this PR we're adding an `allowPartialStream` option, that allows consumers to close the stream normally. The Flight Client's `close()` function then transitions pending chunks to halted instead of erroring them. Halted chunks keep Suspense fallbacks showing (i.e. they never resolve), and their `.then()` is a no-op so no new listeners accumulate. Inner stream chunks (ReadableStream/AsyncIterable) are closed gracefully, and `getChunk()` returns halted chunks for new IDs that are accessed after closing the response. Blocked chunks are left alone because they may be waiting on client-side async operations like module loading, or on forward references to chunks that appeared later in the stream, both of which resolve independently of closing.
unstubbableforce-pushed
the
allow-partial-stream
branch
from
February 9, 2026 15:50
0ae94ef to
2337ad0Compareunstubbable
marked this pull request as ready for review
February 9, 2026 15:54
allowPartialStream option to Flight Clientunstable_allowPartialStream option to Flight Clientacdlite
reviewed
Feb 9, 2026
| haltedChunk.reason = null; | ||
| } else if (chunk.status === INITIALIZED && chunk.reason !== null) { | ||
| // Stream chunk - close gracefully instead of erroring. | ||
| chunk.reason.close('"$undefined"'); |
Collaborator
There was a problem hiding this comment.
This could be an alternative API: pass a special reason exported by React
Collaborator
There was a problem hiding this comment.
or similarly, React exports a special AbortController subclass that does this internally
acdlite
approved these changes
Feb 9, 2026
Uh oh!
There was an error while loading. Please reload this page.
unstubbable pushed a commit
to vercel/next.js
that referenced
this pull request
Feb 9, 2026
[diff react/react@2dd9b7cf...272441a9](react/react@2dd9b7c...272441a) <details> <summary>React upstream changes</summary> - react/react#35731 - react/react#35730 </details>
unstubbable added a commit
to vercel/next.js
that referenced
this pull request
Feb 9, 2026
Previously, `createPrefetchResponseStream` intentionally never called `controller.close()` on the wrapper stream, to prevent React Flight from erroring on unresolved references (dynamic holes). However, Chrome and Firefox keep unclosed ReadableStreams with pending reads as native GC roots, preventing the stream — and the entire FlightResponse captured in the `reader.read().then(progress)` closure chain — from being garbage-collected. Now that React Flight supports `unstable_allowPartialStream` as an option for `createFromReadableStream` (react/react#35731), we can close the stream normally. Flight will mark unresolved chunks as "halted" instead of erroring, which is the correct behavior for prefetch responses. Also removes the now-unnecessary `createUnclosingPrefetchStream` wrapper from the legacy prefetch path in `fetch-server-response.ts`. closes#89485
m-kawafuji pushed a commit
to m-kawafuji/next.js
that referenced
this pull request
Aug 8, 2026
…#89722) [diff react/react@2dd9b7cf...272441a9](react/react@2dd9b7c...272441a) <details> <summary>React upstream changes</summary> - react/react#35731 - react/react#35730 </details>
m-kawafuji pushed a commit
to m-kawafuji/next.js
that referenced
this pull request
Aug 8, 2026
Previously, `createPrefetchResponseStream` intentionally never called `controller.close()` on the wrapper stream, to prevent React Flight from erroring on unresolved references (dynamic holes). However, Chrome and Firefox keep unclosed ReadableStreams with pending reads as native GC roots, preventing the stream — and the entire FlightResponse captured in the `reader.read().then(progress)` closure chain — from being garbage-collected. Now that React Flight supports `unstable_allowPartialStream` as an option for `createFromReadableStream` (react/react#35731), we can close the stream normally. Flight will mark unresolved chunks as "halted" instead of erroring, which is the correct behavior for prefetch responses. Also removes the now-unnecessary `createUnclosingPrefetchStream` wrapper from the legacy prefetch path in `fetch-server-response.ts`. closesvercel#89485
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
When using a partial prerender stream, i.e. a prerender that is intentionally aborted before all I/O has resolved, consumers of
createFromReadableStreamwould need to keep the stream unclosed to prevent React Flight from erroring on unresolved chunks. However, some browsers (e.g. Chrome, Firefox) keep unclosed ReadableStreams with pending reads as native GC roots, retaining the entire Flight response.With this PR we're adding an
unstable_allowPartialStreamoption, that allows consumers to close the stream normally. The Flight Client'sclose()function then transitions pending chunks to halted instead of erroring them. Halted chunks keep Suspense fallbacks showing (i.e. they never resolve), and their.then()is a no-op so no new listeners accumulate. Inner stream chunks (ReadableStream/AsyncIterable) are closed gracefully, andgetChunk()returns halted chunks for new IDs that are accessed after closing the response. Blocked chunks are left alone because they may be waiting on client-side async operations like module loading, or on forward references to chunks that appeared later in the stream, both of which resolve independently of closing.